user.cpp

#include "user.h"
#include "qboxlayout.h"
#include "qdatetime.h"
#include "qsqldatabase.h"
#include "ui_user.h"
#include <QInputDialog>
#include <QMessageBox>
#include <QSqlRecord>
#include <QHBoxLayout> // Include necessary headers
#include <QLineEdit>
#include <QComboBox>
#include <QCheckBox>
#include <QMessageBox>
#include <QJsonArray>
#include <QJsonObject>
#include <QJsonDocument>
#include <QSqlQuery>
#include <QSqlError>
#include <QSqlRecord>
#include <QSqlField>
#include <QSqlTableModel>
#include <QDebug>
#include <QVariantList>
#include "user.h"
#include <QDebug>

QString servername ;
QString dbname ;
QSqlDatabase db;
QString dsn;
int UserID =10;
int MusicID =-1;
QString UserType;

QString QPushButtonStyle ="QPushButton {"
                          "    border-radius: 15px;"
                          "    background-color: rgb(172, 172, 172);"
                          "    font: 11pt 'Segoe Print';"
                          "}"
                          "QPushButton  {"
                          "    color: rgb(0, 0, 0);"
                          "}"
                          "QPushButton {"
                          "    border-radius: 15px;"
                          "    color: rgb(255, 255, 255);"
                          "    font: bold 13pt 'Segoe Print';"
                          "    background-color: #000000;"
                          "    border: 2px solid #2fbd59;"
                          "    padding: 5px 15px;"
                          "    box-shadow: 3px 3px 5px rgba(0, 0, 0, 0.5);"
                          "}"
                          "QPushButton:hover {"
                          "    background-color: #555555;"
                          "}";

QString QLableStyle =            "QLabel {"
                                 "    border-radius: 15px;"
                                 "    color: rgb(255, 255, 255);"
                                 "    font: bold 13pt 'Segoe Print';"
                                 "    background-color: #333333;"
                                 "    border: 2px solid #2fbd59;"
                                 "    padding: 5px 15px;"
                                 "    border: 1px solid #888888;"
                                 "  background-color: #2fbd59;"
                                 "}";

QString QMessageBoxStyle ="QMessageBox {"
                          "    border-radius: 15px;"
                          "    background-color: rgb(172, 172, 172);"
                          "    font: 11pt 'Segoe Print';"
                          "}"
                          "QMessageBox  {"
                          "    color: rgb(0, 0, 0);"
                          "}"
                          "QMessageBox {"
                          "    border-radius: 15px;"
                          "    color: rgb(255, 255, 255);"
                          "    font: bold 13pt 'Segoe Print';"
                          "    background-color: #000000;"
                          "    border: 2px solid #2fbd59;"
                          "    padding: 5px 15px;"
                          "    border: 1px solid #888888;"
                          "  background-color: #2fbd59;"
                          "}"
                          "QMessageBox:hover {"
                          "    background-color: #555555;"
                          "}";



User::User(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::User),
    signalMapper(new QSignalMapper(this))
{
    ui->setupUi(this);
    if (UserType=="Artist"||UserType=="Premium"){
        // Connect the signal mapper's mapped signal to the slot
        connect(signalMapper, SIGNAL(mapped(int)), this, SLOT(onSongButtonClicked2(int)));
        if (UserType=="Premium"){
            ui->addmusicpushButton->setVisible(false);
        }

        ui->walletticketspushButton->setStyleSheet(QPushButtonStyle);
        ui->followpushButton->setStyleSheet(QPushButtonStyle);
        ui->likedsongspushButton->setStyleSheet(QPushButtonStyle);
        ui->songspushButton->setStyleSheet(QPushButtonStyle);
        ui->createplaylistpushButton->setStyleSheet(QPushButtonStyle);
        ui->showalluserspushButton->setStyleSheet(QPushButtonStyle);
        ui->logout->setStyleSheet(QPushButtonStyle);
        ui->addmusicpushButton->setStyleSheet(QPushButtonStyle);
        ui->commentsall->setStyleSheet(QPushButtonStyle);
        ui->allplaylists->setStyleSheet(QPushButtonStyle);


        ui->cancle1->setStyleSheet(QPushButtonStyle);
        ui->cancle2->setStyleSheet(QPushButtonStyle);
        ui->cancle3->setStyleSheet(QPushButtonStyle);
        ui->cancle4->setStyleSheet(QPushButtonStyle);
        ui->cancle5->setStyleSheet(QPushButtonStyle);
        ui->cancle6->setStyleSheet(QPushButtonStyle);
        ui->cancle7->setStyleSheet(QPushButtonStyle);
        ui->cancle8->setStyleSheet(QPushButtonStyle);
        ui->cancle9->setStyleSheet(QPushButtonStyle);
        ui->cancle10->setStyleSheet(QPushButtonStyle);
        ui->cancle11->setStyleSheet(QPushButtonStyle);
        ui->cancle12->setStyleSheet(QPushButtonStyle);
        ui->cancle13->setStyleSheet(QPushButtonStyle);
        ui->cancle14->setStyleSheet(QPushButtonStyle);
        ui->cancle15->setStyleSheet(QPushButtonStyle);


        ui->searchcomboBox->addItem("Title");
        ui->searchcomboBox->addItem("Artist");
        ui->searchcomboBox->addItem("Genre");
        ui->searchcomboBox->addItem("Zone");
        ui->searchcomboBox->addItem("Age Category");

        ui->stackedWidget->setCurrentIndex(0);
        int currentYear = QDate::currentDate().year();

        // Populate combo box with years from 1900 to current year
        for (int year = 1900; year <= currentYear; ++year) {
            ui->year->addItem(QString::number(year));
        }
        // Populate months
        QStringList months = {"January", "February", "March", "April", "May", "June",
                              "July", "August", "September", "October", "November", "December"};

        ui->month->addItems(months);
        QStringList days;
        for (int i = 1; i <= 31; ++i) {
            days << QString::number(i);
        }

        ui->day->addItems(days);
        refreshmainpage();
    }

    else{//normal user
        ui->stackedWidget->setCurrentIndex(10);
        ui->searchcomboBox_2->addItem("Title");
        ui->searchcomboBox_2->addItem("Artist");
        ui->searchcomboBox_2->addItem("Genre");
        ui->searchcomboBox_2->addItem("Zone");
        ui->searchcomboBox_2->addItem("Age Category");
        QSqlQuery query;
        query.prepare("EXEC GetWalletBalance @UserID=:userID");
        query.bindValue(":userID", UserID);

        if (!query.exec()) {
            QMessageBox::critical(this, "Error", "Failed to fetch wallet balance: " + query.lastError().text());
            return;
        }

        if (query.next()) {
            if (query.record().indexOf("WalletBalance") != -1) {
                double walletBalance = query.value("WalletBalance").toDouble();
                QString balanceText = QString::number(walletBalance, 'f', 2);
                ui->balancelabel_2->setText(" $" + balanceText);
            } else {
                QString message = query.value("Message").toString();
                ui->balancelabel_2->setText(message);
            }
        }
    }

}

User::~User()
{
    delete ui;
}
QSqlDatabase createDatabaseConnection(const QString &connectionName) {
    QSqlDatabase db = QSqlDatabase::addDatabase("QODBC", connectionName);
    QString servername = "LOCALHOST\\SQLEXPRESS";
    QString dbname = "Spotify2";
    QString dsn = QString("DRIVER={ODBC Driver 17 for SQL Server};SERVER=%1;DATABASE=%2;Trusted_Connection=Yes;").arg(servername).arg(dbname);
    db.setDatabaseName(dsn);

    if (!db.open()) {
        qDebug() << "Database connection failed:" << db.lastError().text();
    } else {
        qDebug() << "Database opened successfully!";
    }

    return db;
}

void User::refreshmainpage()
{
    QList<QString> playlistNames;

    // Initialize QSqlQuery with a valid database connection
    QSqlQuery query(QSqlDatabase::database());

    // Check if the database connection is open
    if (!db.isOpen()) {
        qDebug() << "Database is not open!";
        return;
    }

    // Prepare and execute the procedure
    query.prepare("EXEC GetUserPlaylistsDetail :user_id");
    query.bindValue(":user_id", UserID);

    if (!query.exec()) {
        qDebug() << "Query execution error:" << query.lastError().text();
        return;
    }

    // Read the results
    while (query.next()) {
        QString playlistName = query.value("playlist_name").toString();
        playlistNames.append(playlistName);
    }

    // List of QLabel pointers
    QList<QLabel*> labels = {ui->namesong1lable_2, ui->namesong2lable_2, ui->namesong3lable_2, ui->namesong4lable_2, ui->namesong5lable_2};

    // Clear all labels
    for (QLabel* label : labels) {
        label->clear();
    }

    // Set text to labels from playlistNames
    int count = qMin(labels.size(), playlistNames.size());
    for (int i = 0; i < count; ++i) {
        labels[i]->setText(playlistNames[i]);
    }

    // Show labels
    for (QLabel* label : labels) {
        label->show();
    }
}
//------------------------------------------------------------ Wallet and tickets ------------------------------------------------------------

void User::on_walletticketspushButton_clicked()
{
    QSqlQuery query;
    query.prepare("EXEC GetWalletBalance @UserID=:userID");
    query.bindValue(":userID", UserID);

    if (!query.exec()) {
        QMessageBox::critical(this, "Error", "Failed to fetch wallet balance: " + query.lastError().text());
        return;
    }

    if (query.next()) {
        if (query.record().indexOf("WalletBalance") != -1) {
            double walletBalance = query.value("WalletBalance").toDouble();
            QString balanceText = QString::number(walletBalance, 'f', 2);
            ui->balancelabel->setText(" $" + balanceText);
        } else {
            QString message = query.value("Message").toString();
            ui->balancelabel->setText(message);
        }
    }
    ui->stackedWidget->setCurrentIndex(1);

    // Clear the previous content
    QWidget *oldContent = ui->scrollArea->widget();
    if (oldContent) {
        delete oldContent;
    }

    // Create a new content widget and layout
    QWidget *contentWidget = new QWidget(this);
    QVBoxLayout *layout = new QVBoxLayout(contentWidget);


    // Prepare the query to call the stored procedure
    QSqlQuery queryValid(db);
    queryValid.prepare("EXEC ShowValidTickets @user_id=:userID");
    queryValid.bindValue(":userID", UserID);

    // Execute the query and handle errors
    if (!queryValid.exec()) {
        QMessageBox::critical(this, "Query Error", "Failed to retrieve valid tickets: " + queryValid.lastError().text());
        return;
    }

    // Iterate over the results and populate the UI
    while (queryValid.next()) {
        QHBoxLayout *hLayout = new QHBoxLayout();

        QLabel *ticketIDLabel = new QLabel("Ticket ID: " + queryValid.value("ticket_id").toString(), contentWidget);
        ticketIDLabel->setFixedSize(150, 50);
        hLayout->addWidget(ticketIDLabel);

        QLabel *artistLabel = new QLabel("Artist: " + queryValid.value("Artist_information").toString(), contentWidget);
        artistLabel->setFixedSize(150, 50);
        hLayout->addWidget(artistLabel);

        QLabel *dateLabel = new QLabel("Date: " + queryValid.value("concert_date").toString(), contentWidget);
        dateLabel->setFixedSize(220, 50);
        hLayout->addWidget(dateLabel);

        QLabel *locationLabel = new QLabel("Location: " + queryValid.value("location").toString(), contentWidget);
        locationLabel->setFixedSize(200, 50);
        hLayout->addWidget(locationLabel);

        QLabel *priceLabel = new QLabel("Price: " + queryValid.value("price").toString(), contentWidget);
        priceLabel->setFixedSize(150, 50);
        hLayout->addWidget(priceLabel);

        layout->addLayout(hLayout);
    }

    // Set the new content widget to the scroll area
    ui->scrollArea->setWidget(contentWidget);
    //    QWidget *contentWidget = new QWidget(this);
    //    QVBoxLayout *layout = new QVBoxLayout(contentWidget);


    //    for (int i = 1; i <= 100; ++i)
    //    {
    //        QHBoxLayout *hLayout = new QHBoxLayout();


    //        QLabel *singerLabel = new QLabel("Singer " + QString::number(i), contentWidget);
    //        singerLabel->setFixedSize(250, 50);
    //        hLayout->addWidget(singerLabel);


    //        QLabel *locationLabel = new QLabel("Location " + QString::number(i), contentWidget);
    //        locationLabel->setFixedSize(250, 50);
    //        hLayout->addWidget(locationLabel);


    //        QLabel *dateLabel = new QLabel("Date " + QString::number(i), contentWidget);
    //        dateLabel->setFixedSize(250, 50);
    //        hLayout->addWidget(dateLabel);

    //        layout->addLayout(hLayout);
    //    }

    //    ui->scrollArea->setWidget(contentWidget);


}

//**charge account
void User::on_chargepushButton_clicked()
{
    QString amountText = ui->lineEdit->text().trimmed();

    if (amountText.isEmpty()) {
        QMessageBox::warning(this, "Error", "Please enter an amount.");
        return;
    }

    bool ok;
    double amount = amountText.toDouble(&ok);

    if (!ok) {
        QMessageBox::warning(this, "Error", "Invalid amount format.");
        return;
    }

    // Assuming db is your QSqlDatabase object, and you have established a connection
    QSqlQuery query(db);

    query.prepare("EXEC RechargeWallet @UserID=:userID, @Amount=:amount");
    query.bindValue(":userID", UserID); // Replace with actual user ID
    query.bindValue(":amount", amount);

    if (!query.exec()) {
        QMessageBox::critical(this, "Error", "Failed to recharge wallet: " + query.lastError().text());
        return;
    }

    if (query.next()) {
        QString message = query.value(0).toString(); // "Recharge successful!" or "No wallet found..."
        QMessageBox::information(this, "Info", message);

        if (query.record().indexOf("UpdatedBalance") != -1) {
            double updatedBalance = query.value("UpdatedBalance").toDouble();
            // Assuming updateUserBalance is a method in your User class or related backend logic
            updateUserBalance(updatedBalance);
        }
    }
}

//** buy premium account
int getUserBalance() {
    return 100;
}
void User::updateUserBalance(int newBalance) {
    // Assuming you have a member variable to store balance
    int balance = newBalance;

    // Update the UI directly, for example, updating a QLabel to show the new balance
    ui->balancelabel->setText(" $" + QString::number(newBalance));

    // You can also perform other actions that you would typically handle in the slot
}

void User::on_buypremiumpushButton_clicked()
{
    int userBalance = getUserBalance();
    int premiumCost = 100;

    QString messageBoxStyle = "QMessageBox {"
                              "    border-radius: 15px;"
                              "    background-color: rgb(172, 172, 172);"
                              "    font: 11pt 'Segoe Print';"
                              "}"
                              "QLabel {"
                              "    color: rgb(0, 0, 0);"
                              "}"
                              "QPushButton {"
                              "    border-radius: 15px;"
                              "    color: rgb(255, 255, 255);"
                              "    font: bold 13pt 'Segoe Print';"
                              "    background-color: #000000;"
                              "    border: 2px solid #2fbd59;"
                              "    padding: 5px 15px;"
                              "    box-shadow: 3px 3px 5px rgba(0, 0, 0, 0.5);"
                              "}"
                              "QPushButton:hover {"
                              "    background-color: #555555;"
                              "}";

    if (userBalance >= premiumCost) {
        updateUserBalance(userBalance - premiumCost);

        QMessageBox successBox;
        successBox.setStyleSheet(messageBoxStyle);
        successBox.setIcon(QMessageBox::Information);
        successBox.setWindowTitle("Success");
        successBox.setText("Premium account purchased successfully.");
        successBox.exec();
    } else {
        QMessageBox errorBox;
        errorBox.setStyleSheet(messageBoxStyle);
        errorBox.setIcon(QMessageBox::Critical);
        errorBox.setWindowTitle("Error");
        errorBox.setText("Insufficient balance to purchase premium account.");
        errorBox.exec();
    }
}

//** full ticketd's scrollbox
void User::on_validticketspushButton_clicked()
{
    // Clear the previous content
    QWidget *oldContent = ui->scrollArea->widget();
    if (oldContent) {
        delete oldContent;
    }

    // Create a new content widget and layout
    QWidget *contentWidget = new QWidget(this);
    QVBoxLayout *layout = new QVBoxLayout(contentWidget);


    // Prepare the query to call the stored procedure
    QSqlQuery query(db);
    query.prepare("EXEC ShowValidTickets @user_id=:userID");
    query.bindValue(":userID", UserID);

    // Execute the query and handle errors
    if (!query.exec()) {
        QMessageBox::critical(this, "Query Error", "Failed to retrieve valid tickets: " + query.lastError().text());
        return;
    }

    // Iterate over the results and populate the UI
    while (query.next()) {
        QHBoxLayout *hLayout = new QHBoxLayout();

        QLabel *ticketIDLabel = new QLabel("Ticket ID: " + query.value("ticket_id").toString(), contentWidget);
        ticketIDLabel->setFixedSize(150, 50);
        hLayout->addWidget(ticketIDLabel);

        QLabel *artistLabel = new QLabel("Artist: " + query.value("Artist_information").toString(), contentWidget);
        artistLabel->setFixedSize(150, 50);
        hLayout->addWidget(artistLabel);

        QLabel *dateLabel = new QLabel("Date: " + query.value("concert_date").toString(), contentWidget);
        dateLabel->setFixedSize(220, 50);
        hLayout->addWidget(dateLabel);

        QLabel *locationLabel = new QLabel("Location: " + query.value("location").toString(), contentWidget);
        locationLabel->setFixedSize(200, 50);
        hLayout->addWidget(locationLabel);

        QLabel *priceLabel = new QLabel("Price: " + query.value("price").toString(), contentWidget);
        priceLabel->setFixedSize(150, 50);
        hLayout->addWidget(priceLabel);

        layout->addLayout(hLayout);
    }

    // Set the new content widget to the scroll area
    ui->scrollArea->setWidget(contentWidget);
}


void User::on_expiredticketspushButton_clicked()
{
    QWidget *contentWidget = new QWidget(this);
    QVBoxLayout *layout = new QVBoxLayout(contentWidget);

    QSqlQuery query(db);
    query.prepare("EXEC ShowInvalidTickets @user_id = :user_id");
    query.bindValue(":user_id", UserID); // Assuming userID is defined and holds the current user's ID

    if (!query.exec()) {
        QMessageBox::critical(nullptr, "Database Error", query.lastError().text());
        return;
    }

    while (query.next()) {
        QHBoxLayout *hLayout = new QHBoxLayout();

        // Extract data from the query result
        QString artistInfo = query.value("Artist_information").toString();
        QString location = query.value("location").toString();
        QString concertDate = query.value("concert_date").toString();
        QString price = query.value("price").toString();

        // Create labels for the UI
        QLabel *singerLabel = new QLabel(artistInfo, contentWidget);
        singerLabel->setFixedSize(150, 50);
        hLayout->addWidget(singerLabel);

        QLabel *locationLabel = new QLabel(location, contentWidget);
        locationLabel->setFixedSize(200, 50);
        hLayout->addWidget(locationLabel);

        QLabel *dateLabel = new QLabel(concertDate, contentWidget);
        dateLabel->setFixedSize(220, 50);
        hLayout->addWidget(dateLabel);

        QLabel *priceLabel = new QLabel(price, contentWidget);
        priceLabel->setFixedSize(150, 50);
        hLayout->addWidget(priceLabel);

        layout->addLayout(hLayout);
    }

    ui->scrollArea->setWidget(contentWidget);
}

//** buy ticket's concert
void User::on_buyticketspushButton_clicked()
{
    QSqlQuery query(db);
    if (!query.exec("EXEC GetUpcomingConcertDetails")) {
        qDebug() << "Stored procedure execution error: " << query.lastError().text();
        return;
    }

    // Process the results
    QStringList artists, locations, dates;
    QList<int> numRegularTickets, regularTicketPrices;
    QList<int> numVIPTickets, vipTicketPrices;
    QList<int> numPremiumTickets, premiumTicketPrices;
    QList<int> concert_IDs;

    while (query.next()) {
        if (query.record().count() == 1) { // Check if the result is the message
            qDebug() << query.value(0).toString();
            return;
        }

        //qDebug() <<query.value("concert_id").toInt();
        concert_IDs << query.value("concert_id").toInt();
        artists << query.value("artist").toString();
        locations << query.value("location").toString();
        dates << query.value("date").toString();
        numRegularTickets << query.value("NumRegularTickets").toInt();
        regularTicketPrices << query.value("RegularTicketPrice").toInt();
        numVIPTickets << query.value("NumVIPTickets").toInt();
        vipTicketPrices << query.value("VIPTicketPrice").toInt();
        numPremiumTickets << query.value("NumPremiumTickets").toInt();
        premiumTicketPrices << query.value("PremiumTicketPrice").toInt();
    }

    ui->stackedWidget->setCurrentIndex(6);

    // Clear previous content
    QWidget *contentWidget = new QWidget(this);
    QGridLayout *layout = new QGridLayout(contentWidget);
    layout->setContentsMargins(20, 20, 20, 20); // Set margins for layout



    // Populate the layout with fetched data
    for (int i = 0; i < artists.size(); ++i)
    {
        // Create label for artist name
        QLabel *artistLabel = new QLabel(artists[i], contentWidget);
        artistLabel->setFixedSize(250, 100);
        artistLabel->setStyleSheet(QLableStyle);
        layout->addWidget(artistLabel, i, 0); ////////////

        // Create label for concert location
        QLabel *locationLabel = new QLabel(locations[i], contentWidget);
        locationLabel->setFixedSize(250, 100);
        locationLabel->setStyleSheet(QLableStyle);
        layout->addWidget(locationLabel, i, 1); ////////////

        // Create label for concert date
        QLabel *dateLabel = new QLabel(dates[i], contentWidget);
        dateLabel->setFixedSize(250, 100);
        dateLabel->setStyleSheet(QLableStyle);
        layout->addWidget(dateLabel, i, 2); ///////////

        // Create VIP button
        QPushButton *vipButton = new QPushButton("VIP\n" + QString::number(numVIPTickets[i]) + " Tickets\n$" + QString::number(vipTicketPrices[i]), contentWidget);
        vipButton->setFixedSize(150, 100);
        vipButton->setStyleSheet(QPushButtonStyle);
        vipButton->setProperty("concert_id", concert_IDs[i]);
        //qDebug()<<concert_IDs[i];
        vipButton->setProperty("ticket_type", "VIP");
        layout->addWidget(vipButton, i, 3); /////////
        connect(vipButton, &QPushButton::clicked, this, &User::handleTicketButtonClicked);

        // Create Regular button
        QPushButton *regularButton = new QPushButton("Regular\n" + QString::number(numRegularTickets[i]) + " Tickets\n$" + QString::number(regularTicketPrices[i]), contentWidget);
        regularButton->setFixedSize(150, 100);
        regularButton->setStyleSheet(QPushButtonStyle);
        regularButton->setProperty("concert_id", concert_IDs[i]);
        regularButton->setProperty("ticket_type", "Regular");
        layout->addWidget(regularButton, i, 4); // Add to grid layout at row i, column 4
        connect(regularButton, &QPushButton::clicked, this, &User::handleTicketButtonClicked);

        // Create Premium button
        QPushButton *premiumButton = new QPushButton("Premium\n" + QString::number(numPremiumTickets[i]) + " Tickets\n$" + QString::number(premiumTicketPrices[i]), contentWidget);
        premiumButton->setFixedSize(150, 100);
        premiumButton->setStyleSheet(QPushButtonStyle);
        premiumButton->setProperty("concert_id", concert_IDs[i]);
        premiumButton->setProperty("ticket_type", "Premium");
        layout->addWidget(premiumButton, i, 5); ////////
        connect(premiumButton, &QPushButton::clicked, this, &User::handleTicketButtonClicked);
    }

    ui->scrollArea_12->setWidget(contentWidget);
}


void User::handleTicketButtonClicked()
{
    QPushButton *button = qobject_cast<QPushButton *>(sender());
    if (!button) {
        return;
    }

    int concertId = button->property("concert_id").toInt();
    QString ticketType = button->property("ticket_type").toString();

    qDebug() << "Concert ID:" << concertId << ", Ticket Type:" << ticketType;

    // Prepare and execute the SQL query to call the stored procedure
    QSqlQuery query;
    query.prepare("EXEC BuyTicket :user_id, :concert_id, :ticket_type");
    query.bindValue(":user_id", UserID);
    query.bindValue(":concert_id", concertId);
    query.bindValue(":ticket_type", ticketType);

    if (!query.exec()) {
        qDebug() << "Stored procedure execution error:" << query.lastError().text();
        QMessageBox::warning(this, "Error", "Failed to execute the stored procedure.");
        return;
    }

    if (query.next()) {
        QString message = query.value("Message").toString();
        qDebug() << "Message:" << message;
        QMessageBox::information(this, "Purchase Result", message);
    }
}

//----------------------------------------------------------- following page --------------------------------------------------------------

void User::on_followpushButton_clicked()
{
    ui->stackedWidget->setCurrentIndex(2);

    // Clear previous content
    delete ui->scrollArea_11->widget();

    QWidget *contentWidget = new QWidget(this);
    QVBoxLayout *layout = new QVBoxLayout(contentWidget);


    // Execute the stored procedure
    QSqlQuery query;
    if (!query.exec("EXEC GetAllArtists")) {
        QMessageBox::critical(this, "Query Error", "Failed to execute stored procedure: " + query.lastError().text());
        return;
    }

    // Check if there are any artists in the database
    bool hasArtists = false;

    // Iterate over the results
    while (query.next()) {
        hasArtists = true;

        int artistID = query.value("artist_id").toInt();
        QString artistName = query.value("Name").toString();

        QHBoxLayout *hLayout = new QHBoxLayout();

        QLabel *nameLabel = new QLabel(artistName, contentWidget);
        nameLabel->setFixedSize(200, 50);
        hLayout->addWidget(nameLabel);

        // Create button for follow request
        QPushButton *followButton = new QPushButton("Follow", contentWidget);
        followButton->setProperty("ID", QString::number(artistID));
        followButton->setFixedSize(140, 50);
        connect(followButton, &QPushButton::clicked, this, &User::onFollowButtonSingerClicked);
        followButton->setStyleSheet(QPushButtonStyle);
        hLayout->addWidget(followButton);

        layout->addLayout(hLayout);
    }

    if (!hasArtists) {
        qDebug() << "No artists found in the database.";
    }

    ui->scrollArea_11->setWidget(contentWidget);


    ///////////////////////////////////////////////////// following singers /////////////////////////////////
    // Clear previous content
    delete ui->scrollArea_10->widget();

    QWidget *contentWidget1 = new QWidget(this);
    QVBoxLayout *layout1 = new QVBoxLayout(contentWidget1);


    // Prepare the stored procedure call
    QSqlQuery queryFollowingSingers;
    queryFollowingSingers.prepare("EXEC GetFollowedArtists @UserID = :userID");
    queryFollowingSingers.bindValue(":userID", UserID);

    // Execute the stored procedure
    if (!queryFollowingSingers.exec()) {
        QMessageBox::critical(this, "Query Error", "Failed to execute stored procedure: " + queryFollowingSingers.lastError().text());
        return;
    }

    // Check if there are any followed artists in the database
    bool hasArtistsFollowing = false;

    // Iterate over the results
    while (queryFollowingSingers.next()) {
        hasArtistsFollowing = true;

        QString artistName = queryFollowingSingers.value("Name").toString();

        QHBoxLayout *hLayout = new QHBoxLayout();

        QLabel *nameLabel = new QLabel(artistName, contentWidget1);
        nameLabel->setFixedSize(150, 50);
        hLayout->addWidget(nameLabel);

        layout1->addLayout(hLayout);
    }

    if (!hasArtistsFollowing) {
        QLabel *noArtistsLabel = new QLabel("No following artist!", contentWidget1);
        noArtistsLabel->setFixedSize(150, 50);
        layout1->addWidget(noArtistsLabel);
    }

    ui->scrollArea_10->setWidget(contentWidget1);

    ///////////////////////////////////////////////////// following others /////////////////////////////////
    // Clear previous content
    delete ui->scrollArea_13->widget();

    QWidget *contentWidget2 = new QWidget(this);
    QVBoxLayout *layout2 = new QVBoxLayout(contentWidget2);



    // Prepare the stored procedure call
    QSqlQuery queryFollowingOthers;
    queryFollowingOthers.prepare("EXEC GetFollowedNonArtists @UserID = :userID");
    queryFollowingOthers.bindValue(":userID", UserID);

    // Execute the stored procedure
    if (!queryFollowingOthers.exec()) {
        QMessageBox::critical(this, "Query Error", "Failed to execute stored procedure: " + queryFollowingOthers.lastError().text());
        return;
    }

    // Check if there are any followed non-artists in the database
    bool hasNonArtists = false;

    // Iterate over the results
    while (queryFollowingOthers.next()) {
        hasNonArtists = true;
        QString userName = queryFollowingOthers.value("Name").toString();

        QHBoxLayout *hLayout2 = new QHBoxLayout();

        QLabel *nameLabel2 = new QLabel(userName, contentWidget2);
        nameLabel2->setFixedSize(150, 50);
        hLayout2->addWidget(nameLabel2);

        layout2->addLayout(hLayout2);
    }

    if (!hasNonArtists) {
        QLabel *noNonArtistsLabel = new QLabel("No following", contentWidget2);
        noNonArtistsLabel->setFixedSize(150, 50);
        layout2->addWidget(noNonArtistsLabel);
    }

    ui->scrollArea_13->setWidget(contentWidget2);

    ///////////////////////////////////////////////////// accepted and rejected request /////////////////////////////////
    QWidget *contentWidget3 = new QWidget(this);
    QVBoxLayout *layout3 = new QVBoxLayout(contentWidget3);

    QSqlQuery queryNotPending;
    queryNotPending.prepare("{ CALL GetNonPendingRequestsForReceiver(?) }");
    queryNotPending.bindValue(0, UserID);

    if (!queryNotPending.exec()) {
        qDebug() << "Stored procedure execution error:" << queryNotPending.lastError().text();
        return;
    }

    int i = 1;
    while (queryNotPending.next()) {
        QString senderName = queryNotPending.value(0).toString();
        QString status = queryNotPending.value(1).toString();

        QHBoxLayout *hLayout3 = new QHBoxLayout();
        QLabel *nameLabel3 = new QLabel(senderName + " (" + status + ")", contentWidget3);
        nameLabel3->setFixedSize(200, 50);
        hLayout3->addWidget(nameLabel3);
        layout3->addLayout(hLayout3);

        ++i;
    }

    ui->scrollArea_14->setWidget(contentWidget3);
    //    QWidget *contentWidget3 = new QWidget(this);
    //    QVBoxLayout *layout3 = new QVBoxLayout(contentWidget3);

    //    for (int i = 1; i <= 10; ++i) {
    //        QHBoxLayout *hLayout3 = new QHBoxLayout();

    //        QLabel *nameLabel3 = new QLabel("accept " + QString::number(i), contentWidget3);
    //        nameLabel3->setFixedSize(150, 50);
    //        hLayout3->addWidget(nameLabel3);
    //        layout3->addLayout(hLayout3);
    //    }

    //    ui->scrollArea_14->setWidget(contentWidget3);

    ///////////////////////////////////////////////////// pending request /////////////////////////////////
    // Clear the previous contents of contentWidget4
    delete ui->scrollArea_15->widget();
    QWidget *contentWidget4 = new QWidget(this);
    QVBoxLayout *layout4 = new QVBoxLayout(contentWidget4);

    // Prepare the SQL query to call the stored procedure
    QSqlQuery queryPending;
    queryPending.prepare("EXEC GetFriendRequestsForUser :UserID");
    queryPending.bindValue(":UserID", UserID);

    // Execute the query and check for errors
    if (queryPending.exec()) {
        while (queryPending.next()) {
            int requestUserID = queryPending.value("UserID").toInt();
            int friendID = queryPending.value("FriendID").toInt();
            QString requesterName = queryPending.value("RequesterName").toString();

            QHBoxLayout *hLayout4 = new QHBoxLayout();

            QLabel *nameLabel4 = new QLabel(requesterName, contentWidget4);
            nameLabel4->setFixedSize(150, 50);
            hLayout4->addWidget(nameLabel4);

            QPushButton *acceptButton = new QPushButton("Accept", contentWidget4);
            acceptButton->setProperty("RequestUserID", requestUserID);
            acceptButton->setProperty("FriendID", friendID);
            acceptButton->setFixedSize(100, 50);
            hLayout4->addWidget(acceptButton);
            connect(acceptButton, &QPushButton::clicked, this, &User::onAcceptButtonClicked);

            QPushButton *rejectButton = new QPushButton("Reject", contentWidget4);
            rejectButton->setProperty("RequestUserID", requestUserID);
            rejectButton->setProperty("FriendID", friendID);
            rejectButton->setFixedSize(100, 50);
            hLayout4->addWidget(rejectButton);
            connect(rejectButton, &QPushButton::clicked, this, &User::onRejectButtonClicked);

            layout4->addLayout(hLayout4);
        }
    } else {
        qDebug() << "Error executing stored procedure:" << queryPending.lastError().text();
        QMessageBox::warning(this, "Error", "Failed to retrieve friend requests.");
    }

    ui->scrollArea_15->setWidget(contentWidget4);




}


void User::onAcceptButtonClicked() {
    QPushButton *button = qobject_cast<QPushButton*>(sender());
    int friendID = button->property("RequestUserID").toInt();
    int userID = UserID; // Replace with the actual user ID of the current user

    qDebug() << "Accept friend request button clicked for user:" << friendID;
    qDebug() << "Current User ID:" << userID;

    // Prepare the SQL query to call the stored procedure
    QSqlQuery query;
    query.prepare("EXEC AcceptFriendRequest :UserID, :FriendID");
    query.bindValue(":UserID", userID);
    query.bindValue(":FriendID", friendID);

    // Execute the query and check for errors
    if (query.exec()) {
        if (query.next()) {
            QString message = query.value(0).toString();
            qDebug() << "Stored Procedure Result:" << message;
            QMessageBox::information(this, "Friend Request", message);
            // Refresh friend requests list
            //loadFriendRequests();
        }
    } else {
        qDebug() << "Error executing stored procedure:" << query.lastError().text();
        QMessageBox::warning(this, "Error", "Failed to accept friend request.");
    }
}


void User::onRejectButtonClicked() {
    QPushButton *button = qobject_cast<QPushButton*>(sender());
    int friendID = button->property("RequestUserID").toInt();
    int userID = UserID; // Replace with the actual user ID of the current user

    qDebug() << "Reject friend request button clicked for user:" << friendID;

    // Prepare the SQL query to call the stored procedure
    QSqlQuery query;
    query.prepare("EXEC RejectFriendRequest :UserID, :FriendID");
    query.bindValue(":UserID", userID);
    query.bindValue(":FriendID", friendID);

    // Execute the query and check for errors
    if (query.exec()) {
        if (query.next()) {
            QString message = query.value(0).toString();
            qDebug() << "Stored Procedure Result:" << message;
            QMessageBox::information(this, "Friend Request", message);
            // Refresh friend requests list
            //loadFriendRequests();
        }
    } else {
        qDebug() << "Error executing stored procedure:" << query.lastError().text();
        QMessageBox::warning(this, "Error", "Failed to reject friend request.");
    }
}


//// Example function to update friend request status
//void User::updateFriendRequestStatus(int userID, int friendID, const QString &status) {
//    QSqlQuery query;
//    query.prepare("UPDATE Friends SET Status = :Status WHERE UserID = :UserID AND FriendID = :FriendID");
//    query.bindValue(":Status", status);
//    query.bindValue(":UserID", userID);
//    query.bindValue(":FriendID", friendID);

//    if (!query.exec()) {
//        qDebug() << "Error updating friend request status:" << query.lastError().text();
//    }
//}


void User::onFollowButtonSingerClicked() {
    QPushButton *button = qobject_cast<QPushButton*>(sender());
    QString followedUserID = button->property("ID").toString();
    //qDebug() << "Follow button clicked for user:" << followedUserID;


    // Prepare the stored procedure call
    QSqlQuery query;
    query.prepare("EXEC AddFollower @FollowerID = :followerID, @FollowedID = :followedID");
    query.bindValue(":followerID", UserID); // Assuming you have a variable currentUserID for the logged-in user
    query.bindValue(":followedID", followedUserID);

    // Execute the stored procedure
    if (!query.exec()) {
        QMessageBox::critical(this, "Query Error", "Failed to execute stored procedure: " + query.lastError().text());
        return;
    }

    // Fetch the result message
    if (query.next()) {
        QString message = query.value("Message").toString();
        qDebug() << "Message from stored procedure:" << message;
        QMessageBox::information(this, "Information", message);
    }

}

// ---> hameye mavared baiad por shavad


//------------------------------------------------------------ Liked songs ---------------------------------------------------------------

void User::on_likedsongspushButton_clicked()
{
    ui->stackedWidget->setCurrentIndex(13);

    ui->tabWidget_3->setCurrentIndex(0);
    ui->tabWidget_3->setTabText(0, "Musics");
    ui->tabWidget_3->setTabText(2, "Albums");
    ui->tabWidget_3->setTabText(1, "Playlists");

    // Get liked musics by user and friends
    QSqlQuery queryMusic(db);
    queryMusic.prepare("EXEC GetUserAndFriendsLikedSongs @UserID = :user_id");
    queryMusic.bindValue(":user_id", UserID);

    if (!queryMusic.exec()) {
        QMessageBox::critical(this, "Error", "Failed to execute procedure: " + queryMusic.lastError().text());
        return;
    }

    QString musicContent;
    bool hasResults = false;
    musicContent="";
    while (queryMusic.next()) {
        hasResults = true;
        QString likerUsername = queryMusic.value("LikerUsername").toString();
        QString songTitle = queryMusic.value("SongTitle").toString();
        musicContent += QString("%1 liked the song '%2'\n\n").arg(likerUsername).arg(songTitle);
    }

    if (!hasResults) {
        musicContent = "No liked songs found.";
    }

    ui->musicsliked->setText(musicContent);

    ///*******************************************************************************************************
    if (!db.isOpen()) {
        QMessageBox::critical(this, "Error", "Database is not open.");
        return;
    }

    QSqlQuery queryalbum(db);
    queryalbum.prepare("EXEC GetLikedAlbums @user_id = :user_id");
    queryalbum.bindValue(":user_id", UserID);

    if (!queryalbum.exec()) {
        QMessageBox::critical(this, "Error", "Failed to execute procedure: " + queryalbum.lastError().text());
        return;
    }

    QString albumContent;
    bool hasResults2 = false;

    while (queryalbum.next()) {
        hasResults2 = true;
        QString albumTitle = queryalbum.value("AlbumTitle").toString();
        albumContent += QString("You liked the album '%1'\n\n").arg(albumTitle);
    }

    if (!hasResults2) {
        albumContent = "No liked albums found.";
    }

    ui->albumsliked->setText(albumContent);

    ///******************************************************************************************************
    QSqlQuery queryplaylist(db);
    queryplaylist.prepare("EXEC GetLikedPlaylistsByUserId @user_id = :user_id");
    queryplaylist.bindValue(":user_id", UserID);

    if (!queryplaylist.exec()) {
        QMessageBox::critical(this, "Error", "Failed to execute procedure: " + queryplaylist.lastError().text());
        return;
    }

    QString playlistContent;
    bool hasResults3 = false;

    while (queryplaylist.next()) {
        hasResults3 = true;
        QString playlistName = queryplaylist.value("playlist_name").toString();
        playlistContent += QString("You liked the playlist '%1'\n\n").arg(playlistName);
    }

    if (!hasResults3) {
        playlistContent = "No liked playlists found.";
    }

    ui->playlistsliked->setText(playlistContent);
}


/* /////////////////////////////////////////////////////////////////// like music /////////////////////////////////////////////////
    // Execute the stored procedure to retrieve liked songs
    QSqlQuery query;
    query.prepare("EXEC ShowLikedMusics @user_id = :user_id");
    query.bindValue(":user_id", UserID);

    if (!query.exec())
    {
        QString error = query.lastError().text();
        QMessageBox::critical(this, "Error", "Failed to execute query: " + error);
        return;
    }
    // Clear the contents of scrollArea_3 before adding new liked songs
    QWidget *oldContent = ui->scrollArea_3->takeWidget();
    if (oldContent)
    {
        delete oldContent;
    }
    QWidget *contentWidget = new QWidget(this);
    QVBoxLayout *layout = new QVBoxLayout(contentWidget);

    int i = 0;
    while (query.next())
    {
        int musicId = query.value(0).toInt();
        QString musicTitle = query.value(1).toString();

        QHBoxLayout *hLayout = new QHBoxLayout();

        // Create label for song image
        QLabel *label = new QLabel(contentWidget);
        QPixmap pixmap(":/new/prefix1/spotify logo.png");
        pixmap = pixmap.scaled(150, 150, Qt::KeepAspectRatio);
        label->setPixmap(pixmap);
        label->setFixedSize(200, 200);
        hLayout->addWidget(label);

        // Create button for song name
        QPushButton *songButton = new QPushButton(musicTitle, contentWidget);
        songButton->setProperty("ID", musicId);
        songButton->setProperty("name", musicTitle);
        songButton->setProperty("pic_path", ":/new/prefix1/spotify logo.png");
        songButton->setStyleSheet(QPushButtonStyle);

        // Connect the button directly to the slot with a lambda function
        connect(songButton, &QPushButton::clicked, [this, musicId]() {
            onSongButtonClicked2(musicId);
        });

        songButton->setFixedSize(400, 100);

        // Ensure the button keeps the square shape
        QSizePolicy policy(QSizePolicy::Fixed, QSizePolicy::Fixed);
        policy.setHeightForWidth(true);
        songButton->setSizePolicy(policy);

        hLayout->addWidget(songButton);
        layout->addLayout(hLayout);

        i++;
    }

    if (i == 0)
    {
        QMessageBox::information(this, "No Likes", "You have not liked any songs yet.");
    }

    ui->scrollArea_7->setWidget(contentWidget);*/
//}



//------------------------------------------------------------  All songs  ----------------------------------------------------------------
void User::on_songspushButton_clicked()
{
    ui->stackedWidget->setCurrentIndex(3);

    // Clear previous content
    delete ui->scrollArea_3->widget();

    // Check database connection and open if not open
    if (!db.isOpen()) {
        if (!db.open()) {
            QMessageBox::critical(this, "Database Error", "Failed to open the database: " + db.lastError().text());
            return;
        }
    }

    // Prepare the query to call the stored procedure GetAllSongs
    QSqlQuery query;
    query.prepare("EXEC GetAllSongs");

    // Execute the query
    if (!query.exec()) {
        qDebug() << "GetAllSongs stored procedure error:" << query.lastError();
        QMessageBox::critical(this, "Error", "Failed to load songs: " + query.lastError().text());
        return;
    }

    QWidget *contentWidget = new QWidget(this);
    QVBoxLayout *layout = new QVBoxLayout(contentWidget);

    // Loop through the results
    while (query.next()) {
        int songID = query.value(0).toInt();
        QString songTitle = query.value(1).toString();

        QHBoxLayout *hLayout = new QHBoxLayout();

        // Create label for song image
        QLabel *label = new QLabel(contentWidget);
        QPixmap pixmap(":/new/prefix1/spotify logo.png");
        pixmap = pixmap.scaled(150, 150, Qt::KeepAspectRatio);
        label->setPixmap(pixmap);
        label->setFixedSize(200, 200);
        hLayout->addWidget(label);

        // Create button for song name
        QPushButton *songButton = new QPushButton(songTitle, contentWidget);
        songButton->setProperty("ID", songID);
        songButton->setProperty("name", songTitle);
        songButton->setProperty("pic_path", ":/new/prefix1/spotify logo.png");
        songButton->setStyleSheet(QPushButtonStyle);

        // Connect the button directly to the slot with a lambda function
        connect(songButton, &QPushButton::clicked, [this, songID]() {
            onSongButtonClicked2(songID);
        });

        songButton->setFixedSize(400, 100);

        QSizePolicy policy(QSizePolicy::Fixed, QSizePolicy::Fixed);
        policy.setHeightForWidth(true);
        songButton->setSizePolicy(policy);

        hLayout->addWidget(songButton);
        layout->addLayout(hLayout);
    }

    ui->scrollArea_3->setWidget(contentWidget);
}

//------------------------------------------------------------ Create Playlist -----------------------------------------------------------
void InputDialog::onOkButtonClicked() {
    QString text = lineEdit->text();
    qDebug() << "Text entered:" << text;//////////////////////////////////////////////////////////// name of new playlist
    accept(); // Close the dialog
}

InputDialog::InputDialog(QWidget *parent) : QDialog(parent) {
    QVBoxLayout *layout = new QVBoxLayout(this);

    QLabel *label = new QLabel("Enter New playlist's name :", this);
    lineEdit = new QLineEdit(this);

    privateCheckBox = new QCheckBox("Private", this); // Add the checkbox

    QPushButton *okButton = new QPushButton("OK", this);
    connect(okButton, &QPushButton::clicked, this, &InputDialog::onOkButtonClicked);

    layout->addWidget(label);
    layout->addWidget(lineEdit);
    layout->addWidget(privateCheckBox); // Add checkbox to layout
    layout->addWidget(okButton);

    // Apply stylesheet
    this->setStyleSheet("QDialog { border-radius: 15px; background-color: #333333; }"
                        "QLabel, QLineEdit, QPushButton, QCheckBox { color: rgb(255, 255, 255); font: bold 13pt 'Segoe Print'; }"
                        "QPushButton { background-color: #000000; border: 2px solid #2fbd59; padding: 5px 15px; box-shadow: 3px 3px 5px rgba(0, 0, 0, 0.5); }"
                        "QLineEdit, QCheckBox { background-color: #444444; border: 2px solid #2fbd59; padding: 5px; }");
}

QString InputDialog::getPlaylistName() const {
    return lineEdit->text();
}

bool InputDialog::isPrivate() const {
    return privateCheckBox->isChecked();
}
void createPremiumUserPlaylist(int userID, const QString& playlistName, bool isPrivate) {
    QSqlQuery query;
    query.prepare("EXEC CreatePremiumUserPlaylist :UserID, :PlaylistName, :CreateDate, :IsPrivate");
    query.bindValue(":UserID", userID);
    query.bindValue(":PlaylistName", playlistName);
    query.bindValue(":CreateDate", QDate::currentDate());
    query.bindValue(":IsPrivate", isPrivate);

    if (!query.exec()) {
        QMessageBox::critical(nullptr, QObject::tr("Database Error"), query.lastError().text());
        return;
    }

    // Check for any returned messages from the stored procedure
    if (query.next()) {
        QString message = query.value(0).toString();

        if (message.startsWith("Error:")) {
            // Display the error message
            QMessageBox::critical(nullptr, QObject::tr("Procedure Error"), message);
        } else {
            // If execution successful
            QMessageBox::information(nullptr, QObject::tr("Success"), message);
        }
    }
}
void User::on_createplaylistpushButton_clicked()
{

    //    InputDialog dialog(this);
    //    if (dialog.exec() == QDialog::Accepted) {
    //        QString playlistName = dialog.getPlaylistName();
    //        bool isPrivate = dialog.isPrivate(); // Check the private checkbox status

    //        // Use playlistName and isPrivate as needed
    //        qDebug() << "Playlist Name:" << playlistName;
    //        qDebug() << "Private:" << (isPrivate ? "Yes" : "No");
    //    }


    InputDialog dialog(this);
    if (dialog.exec() == QDialog::Accepted) {
        QString playlistName = dialog.getPlaylistName();
        bool isPrivate = dialog.isPrivate();

        qDebug() << "Playlist Name:" << playlistName;
        qDebug() << "Private:" << (isPrivate ? "Yes" : "No");

        // Execute the stored procedure function
        createPremiumUserPlaylist(UserID, playlistName, isPrivate);
    }

}


//------------------------------------------------------------ Show all users ------------------------------------------------------------

void User::on_showalluserspushButton_clicked()
{
    ui->stackedWidget->setCurrentIndex(4);
    QWidget *contentWidget = new QWidget(this);
    QVBoxLayout *layout = new QVBoxLayout(contentWidget);



    // Execute the stored procedure
    QSqlQuery query;
    if (!query.exec("EXEC GetNonArtistUsers")) {
        QMessageBox::critical(this, "Query Error", "Stored procedure execution failed: " + query.lastError().text());
        return;
    }

    bool hasUsers = false;
    bool hasNonArtistUsers = false;

    // Iterate over the results
    while (query.next()) {
        hasUsers = true;

        // Check for special messages
        if (query.record().indexOf("Message") != -1) {
            QString message = query.value("Message").toString();
            if (message == "No non-artist users in the database") {
                QMessageBox::information(this, "Information", message);
                return;
            } else if (message == "No users in the database") {
                QMessageBox::information(this, "Information", message);
                return;
            }
        } else {
            hasNonArtistUsers = true;
            int userID = query.value("ID").toInt();
            QString userName = query.value("Name").toString();

            QHBoxLayout *hLayout = new QHBoxLayout();

            // Create label for user name
            QLabel *nameLabel = new QLabel(userName, contentWidget);
            nameLabel->setFixedSize(250, 50);
            hLayout->addWidget(nameLabel);

            // Create button for follow request
            QPushButton *followButton = new QPushButton("Follow", contentWidget);
            followButton->setProperty("ID", userID);
            followButton->setFixedSize(150, 50);
            connect(followButton, &QPushButton::clicked, this, &User::onFollowButtonClicked);
            hLayout->addWidget(followButton);
            followButton->setStyleSheet(QPushButtonStyle);

            // Create button for friend request
            QPushButton *friendRequestButton = new QPushButton("Friend Request", contentWidget);
            friendRequestButton->setProperty("ID", userID);
            friendRequestButton->setFixedSize(200, 50);
            connect(friendRequestButton, &QPushButton::clicked, this, &User::onFriendRequestButtonClicked);
            hLayout->addWidget(friendRequestButton);
            friendRequestButton->setStyleSheet(QPushButtonStyle);

            layout->addLayout(hLayout);
        }
    }

    // Check if there were no users or no non-artist users
    if (!hasUsers) {
        QMessageBox::information(this, "Information", "No users in the database.");
    } else if (!hasNonArtistUsers) {
        QMessageBox::information(this, "Information", "No non-artist users in the database.");
    }

    // Set the content widget as the scroll area's widget
    ui->scrollArea_9->setWidget(contentWidget);
    ui->stackedWidget->setCurrentWidget(ui->scrollArea_9);
}

void User::onFollowButtonClicked() {
    QPushButton *button = qobject_cast<QPushButton*>(sender());
    QString followeduserID = button->property("ID").toString();; // Convert ID to integer


    // Prepare the stored procedure call
    QSqlQuery query;
    query.prepare("EXEC AddFollower @FollowerID = :followerID, @FollowedID = :followedID");
    query.bindValue(":followerID", UserID);
    query.bindValue(":followedID", followeduserID);

    // Execute the stored procedure
    if (!query.exec()) {
        QMessageBox::critical(this, "Query Error", "Failed to execute stored procedure: " + query.lastError().text());
        return;
    }

    // Fetch the result message
    if (query.next()) {
        QString message = query.value("Message").toString();
        qDebug() << "Message from stored procedure:" << message;
        QMessageBox::information(this, "Information", message);
    }
}

void User::onFriendRequestButtonClicked() {
    QPushButton *button = qobject_cast<QPushButton*>(sender());
    QString friendIDStr = button->property("ID").toString();
    int friendID = friendIDStr.toInt();
    int userID = UserID; // Replace with the actual user ID of the current user
    qDebug() << "Friend request button clicked for user:" << friendID;

    // Prepare the SQL query to call the stored procedure
    QSqlQuery query;
    query.prepare("EXEC SendFriendRequest :UserID, :FriendID");
    query.bindValue(":UserID", userID);
    query.bindValue(":FriendID", friendID);

    // Execute the query and check for errors
    if (query.exec()) {
        if (query.next()) {
            QString message = query.value(0).toString();
            qDebug() << "Stored Procedure Result:" << message;
            QMessageBox::information(this, "Friend Request", message);
        }
    } else {
        qDebug() << "Error executing stored procedure:" << query.lastError().text();
        QMessageBox::warning(this, "Error", "Failed to send friend request.");
    }
}


//---------------------------------------------------------- All Favorite musics ---------------------------------------------------------
//scrollArea_20  , scrollArea_8
void User::on_showallfavoritesongs_clicked()
{
    ui->stackedWidget->setCurrentIndex(15);
    ui->tabWidget_4->setTabText(0, "Musics");
    ui->tabWidget_4->setTabText(1, "Playlists");

    ///////////   full this page with all favorits
    // Prepare and execute the stored procedure
    QSqlQuery query;
    query.prepare("{ CALL GetFavoriteSongs(?) }");
    query.bindValue(0, UserID); // Assuming user_id is available in this context

    if (!query.exec()) {
        QMessageBox::critical(this, "Query Error", query.lastError().text());
        db.close();
        return;
    }

    QWidget *contentWidget = new QWidget(this);
    QVBoxLayout *layout = new QVBoxLayout(contentWidget);

    while (query.next()) {
        int song_id = query.value(0).toInt();
        QString song_title = query.value(1).toString();

        QHBoxLayout *hLayout = new QHBoxLayout();

        // Create label for song image
        QLabel *label = new QLabel(contentWidget);
        QPixmap pixmap(":/new/prefix1/spotify logo.png");
        pixmap = pixmap.scaled(150, 150, Qt::KeepAspectRatio);
        label->setPixmap(pixmap);
        label->setFixedSize(200, 200);
        hLayout->addWidget(label);

        // Create button for song name
        QPushButton *songButton = new QPushButton(song_title, contentWidget);
        songButton->setProperty("ID", song_id);
        songButton->setProperty("name", song_title);
        songButton->setProperty("pic_path", ":/new/prefix1/spotify logo.png");
        songButton->setStyleSheet(QPushButtonStyle);

        connect(songButton, &QPushButton::clicked, this, &User::onSongButtonClicked);

        songButton->setFixedSize(400, 100); // Set fixed size for square shape
        QSizePolicy policy(QSizePolicy::Fixed, QSizePolicy::Fixed);
        policy.setHeightForWidth(true);
        songButton->setSizePolicy(policy);

        hLayout->addWidget(songButton);
        layout->addLayout(hLayout);
    }

    ui->scrollArea_8->setWidget(contentWidget);
    ///////////////////////////////////////////////////// playlists ----> scrollArea_20

    //    QWidget *contentWidget = new QWidget(this);
    //    QVBoxLayout *layout = new QVBoxLayout(contentWidget);

    //    // Example songs
    //    for (int i = 1; i <= 100; ++i)
    //    {
    //        QHBoxLayout *hLayout = new QHBoxLayout();

    //        // Create label for song image
    //        QLabel *label = new QLabel(contentWidget);
    //        QPixmap pixmap(":/new/prefix1/spotify logo.png");
    //        pixmap = pixmap.scaled(150, 150, Qt::KeepAspectRatio);
    //        // Adjust size to fit within QLabel
    //        label->setPixmap(pixmap);
    //        label->setFixedSize(200, 200);
    //        hLayout->addWidget(label);

    //        // Create button for song name
    //        QPushButton *songButton = new QPushButton("Music " + QString::number(i), contentWidget);
    //        songButton->setProperty("ID", QString::number(i)); // Assuming songID is the same as i for this example
    //        songButton->setProperty("name", "Song " + QString::number(i));
    //        songButton->setProperty("pic_path", ":/new/prefix1/spotify logo.png");
    //        songButton->setStyleSheet(QPushButtonStyle);


    //        connect(songButton, &QPushButton::clicked, this, &User::onSongButtonClicked);

    //        songButton->setFixedSize(400, 100); // Set fixed size for square shape

    //        // Ensure the button keeps the square shape
    //        QSizePolicy policy(QSizePolicy::Fixed, QSizePolicy::Fixed);
    //        policy.setHeightForWidth(true);
    //        songButton->setSizePolicy(policy);

    //        hLayout->addWidget(songButton);
    //        layout->addLayout(hLayout);
    //    }

    //    ui->scrollArea_3->setWidget(contentWidget);
}


//------------------------------------------------------------ All Playlists ------------------------------------------------------------

void User::on_showallplaylists_clicked()
{
    ui->stackedWidget->setCurrentIndex(7);

    int userID = UserID; // Example user ID, replace with actual user ID

    QSqlQuery query;
    query.prepare("{CALL GetUserPlaylistsDetail(?)}");
    query.bindValue(0, userID);

    if (!query.exec()) {
        QMessageBox::critical(this, "Database Error", query.lastError().text());
        return;
    }

    QList<QPair<int, QPair<QString, QString>>> playlists;
    QList<QString> playlistNames; // To store playlist names

    while (query.next()) {
        if (query.record().count() == 1) {
            QString playlistInfo = query.value(0).toString();
            QMessageBox::information(this, "Information", playlistInfo);
            return;
        } else {
            int playlistID = query.value("playlist_id").toInt();
            QString playlistName = query.value("playlist_name").toString();
            QString createDate = query.value("create_date").toString();
            QString privacyStatus = query.value("privacy_status").toString();
            playlists.append(qMakePair(playlistID, qMakePair(createDate, privacyStatus)));
            playlistNames.append(playlistName); // Add playlist name to the list
        }
    }

    QWidget *contentWidget = new QWidget(this);
    QVBoxLayout *layout = new QVBoxLayout(contentWidget);

    for (int i = 0; i < playlists.size(); ++i) {
        int playlistID = playlists.at(i).first;
        QString playlistName = playlistNames.at(i); // Get the actual playlist name
        QHBoxLayout *hLayout = new QHBoxLayout();

        QLabel *label = new QLabel(contentWidget);
        QPixmap pixmap(":/new/prefix1/spotify logo.png");
        pixmap = pixmap.scaled(150, 150, Qt::KeepAspectRatio);
        label->setPixmap(pixmap);
        label->setFixedSize(200, 200);
        hLayout->addWidget(label);

        QPushButton *playlistNameButton = new QPushButton(playlistName, contentWidget); // Use actual playlist name
        playlistNameButton->setFixedSize(200, 50);
        playlistNameButton->setStyleSheet(QPushButtonStyle);
        connect(playlistNameButton, &QPushButton::clicked, this, &User::onShowSongsogPlaylistClicked);
        hLayout->addWidget(playlistNameButton);

        QLabel *createDateLabel = new QLabel(playlists.at(i).second.first, contentWidget);
        createDateLabel->setFixedSize(200, 50);
        createDateLabel->setStyleSheet(QLableStyle);
        hLayout->addWidget(createDateLabel);

        QLabel *privacyLabel = new QLabel(playlists.at(i).second.second, contentWidget);
        privacyLabel->setFixedSize(100, 50);
        privacyLabel->setStyleSheet(QLableStyle);
        hLayout->addWidget(privacyLabel);

        QPushButton *commentButton = new QPushButton("Comment", contentWidget);
        commentButton->setProperty("playlistID", playlistID);
        commentButton->setProperty("playlistName", playlistName); // Set the playlist name as a property
        connect(commentButton, &QPushButton::clicked, this, &User::onCommentPlaylistButtonClicked);
        commentButton->setStyleSheet(QPushButtonStyle);
        hLayout->addWidget(commentButton);

        QPushButton *favoriteButton = new QPushButton("Add to Favorite List", contentWidget);
        favoriteButton->setProperty("playlistID", playlistID);
        favoriteButton->setFixedSize(210, 50);
        favoriteButton->setStyleSheet(QPushButtonStyle);
        connect(favoriteButton, &QPushButton::clicked, this, &User::onAddToFavoriteListButtonClicked);
        hLayout->addWidget(favoriteButton);

        QPushButton *likeButton = new QPushButton("Like", contentWidget);
        likeButton->setProperty("playlistID", playlistID);
        likeButton->setFixedSize(200, 50);
        likeButton->setStyleSheet(QPushButtonStyle);
        connect(likeButton, &QPushButton::clicked, this, &User::onLikePlaylistButtonClicked);
        hLayout->addWidget(likeButton);

        layout->addLayout(hLayout);
    }

    ui->scrollArea_2->setWidget(contentWidget);
}

void User::onCommentPlaylistButtonClicked()
{
    QPushButton *button = qobject_cast<QPushButton*>(sender());
    if (button) {
        QString playlistName = button->property("playlistName").toString();
        int playlistID = button->property("playlistID").toInt();
        int userID = UserID;  // Set the user ID (replace with actual user ID logic)

        // Create a dialog for entering the comment
        QDialog *commentDialog = new QDialog(this);
        commentDialog->setWindowTitle("Enter Comment");

        QVBoxLayout *dialogLayout = new QVBoxLayout(commentDialog);

        QLabel *label = new QLabel("Enter your comment for " + playlistName, commentDialog);
        dialogLayout->addWidget(label);

        QTextEdit *commentTextEdit = new QTextEdit(commentDialog);
        dialogLayout->addWidget(commentTextEdit);

        QHBoxLayout *buttonsLayout = new QHBoxLayout();

        QPushButton *okButton = new QPushButton("OK", commentDialog);
        connect(okButton, &QPushButton::clicked, [this, commentDialog, commentTextEdit, userID, playlistID]() {
            QString comment = commentTextEdit->toPlainText();

            QSqlQuery query;
            query.prepare("EXEC AddPlaylistComment :UserID, :PlaylistID, :Text");
            query.bindValue(":UserID", userID);
            query.bindValue(":PlaylistID", playlistID);
            query.bindValue(":Text", comment);

            if (query.exec()) {
                if (query.next()) {
                    QString message = query.value(0).toString();
                    QMessageBox::information(this, "Result", message);
                }
            } else {
                QMessageBox::critical(this, "Error", "Failed to execute query: " + query.lastError().text());
            }

            commentDialog->accept();
        });
        buttonsLayout->addWidget(okButton);

        QPushButton *cancelButton = new QPushButton("Cancel", commentDialog);
        connect(cancelButton, &QPushButton::clicked, commentDialog, &QDialog::reject);
        buttonsLayout->addWidget(cancelButton);

        dialogLayout->addLayout(buttonsLayout);

        commentDialog->setLayout(dialogLayout);
        commentDialog->exec();
    }
}

void User::onShowSongsogPlaylistClicked()
{
    ui->stackedWidget->setCurrentIndex(3);

    ///////////   full this page with all songs of playlists

    QWidget *contentWidget = new QWidget(this);
    QVBoxLayout *layout = new QVBoxLayout(contentWidget);

    // Example songs
    for (int i = 1; i <= 100; ++i)
    {
        QHBoxLayout *hLayout = new QHBoxLayout();

        // Create label for song image
        QLabel *label = new QLabel(contentWidget);
        QPixmap pixmap(":/new/prefix1/spotify logo.png");
        pixmap = pixmap.scaled(150, 150, Qt::KeepAspectRatio);
        // Adjust size to fit within QLabel
        label->setPixmap(pixmap);
        label->setFixedSize(200, 200);
        hLayout->addWidget(label);

        // Create button for song name
        QPushButton *songButton = new QPushButton("Music " + QString::number(i), contentWidget);
        songButton->setProperty("ID", QString::number(i)); // Assuming songID is the same as i for this example
        songButton->setProperty("name", "Song " + QString::number(i));
        songButton->setProperty("pic_path", ":/new/prefix1/spotify logo.png");
        songButton->setStyleSheet(QPushButtonStyle);


        connect(songButton, &QPushButton::clicked, this, &User::onSongButtonClicked);

        songButton->setFixedSize(400, 100); // Set fixed size for square shape

        // Ensure the button keeps the square shape
        QSizePolicy policy(QSizePolicy::Fixed, QSizePolicy::Fixed);
        policy.setHeightForWidth(true);
        songButton->setSizePolicy(policy);

        hLayout->addWidget(songButton);
        layout->addLayout(hLayout);
    }

    ui->scrollArea_3->setWidget(contentWidget);
}

void User::onAddToFavoriteListButtonClicked() {
    // Identify the button that was clicked
    QPushButton *button = qobject_cast<QPushButton *>(sender());
    if (!button) {
        QMessageBox::critical(nullptr, "Error", "Unable to identify the sender button.");
        return;
    }

    // Retrieve the playlist_id from the button's property
    bool ok;
    int playlistID = button->property("playlistID").toInt(&ok);
    if (!ok) {
        QMessageBox::critical(nullptr, "Error", "Invalid playlist ID.");
        return;
    }


    // Prepare and execute the stored procedure
    QSqlQuery query;
    query.prepare("{ CALL AddToFavoritePlaylists(:user_id, :playlist_id) }");
    query.bindValue(":user_id", UserID);
    query.bindValue(":playlist_id", playlistID);

    if (!query.exec()) {
        QString errorText = "Query execution error: " + query.lastError().text();
        QMessageBox::critical(nullptr, "Query Error", errorText);
        //db.close();
        return;
    }

    // Process the result
    if (query.next()) {
        QString message = query.value("Message").toString();
        if (message.startsWith("Error:")) {
            QMessageBox::warning(nullptr, "Operation Failed", message);
        } else {
            QMessageBox::information(nullptr, "Operation Successful", message);
        }
    } else {
        QMessageBox::critical(nullptr, "Query Error", "No result returned from the stored procedure.");
    }

}

void User::onLikePlaylistButtonClicked() {
    // Get the button that was clicked
    QPushButton *button = qobject_cast<QPushButton *>(sender());
    if (!button) return;

    // Get the playlist ID from the button's property
    int playlistID = button->property("playlistID").toInt();

    // Replace with the actual user ID
    int userID = UserID; // Example user ID

    // Prepare the query
    QSqlQuery query;
    query.prepare("{CALL TogglePlaylistLike(?, ?)}");
    query.bindValue(0, userID);
    query.bindValue(1, playlistID);

    // Execute the query
    if (!query.exec()) {
        QMessageBox::critical(this, "Database Error", query.lastError().text());
        return;
    }

    // Process the result
    if (query.next()) {
        QString message = query.value(0).toString();
        QMessageBox::information(this, "Information", message);
    }
}

// ----------------------------------------------------- All singers -----------------------------------------------------------

void User::on_showallfavoritesingers_clicked()
{
    ui->stackedWidget->setCurrentIndex(8);

    // Full this page with all favorites
    QWidget *contentWidget = new QWidget(this);
    QVBoxLayout *layout = new QVBoxLayout(contentWidget);

    // Example singers
    QSqlQuery query;
    if (!query.exec("EXEC GetAllArtists")) {
        QMessageBox::critical(this, "Error", "Failed to execute stored procedure: " + query.lastError().text());
        return;
    }

    while (query.next()) {
        int artistId = query.value(0).toInt();
        QString artistName = query.value(1).toString();

        QHBoxLayout *hLayout = new QHBoxLayout();

        // Create label for singer image
        QLabel *label = new QLabel(contentWidget);
        QPixmap pixmap(":/new/prefix1/user.png");
        pixmap = pixmap.scaled(150, 150, Qt::KeepAspectRatio);
        // Adjust size to fit within QLabel
        label->setPixmap(pixmap);
        label->setFixedSize(200, 200);
        hLayout->addWidget(label);

        // Create button for singer name
        QPushButton *singerButton = new QPushButton(artistName, contentWidget);
        singerButton->setProperty("ID", artistId);
        singerButton->setProperty("name", artistName);
        singerButton->setProperty("pic_path", ":/new/prefix1/user.png");

        connect(singerButton, &QPushButton::clicked, this, &User::onSingerButtonClicked);

        singerButton->setFixedSize(400, 100); // Set fixed size for square shape

        // Ensure the button keeps the square shape
        QSizePolicy policy(QSizePolicy::Fixed, QSizePolicy::Fixed);
        policy.setHeightForWidth(true);
        singerButton->setSizePolicy(policy);

        hLayout->addWidget(singerButton);
        layout->addLayout(hLayout);
    }

    ui->scrollArea_4->setWidget(contentWidget);
}
void User::getArtistDetails(int artistId)
{
    if (!db.isOpen()) {
        QMessageBox::critical(this, "Error", "Database is not open.");
        return;
    }

    QSqlQuery queryartist(db);
    queryartist.prepare("EXEC GetArtistDetails @artist_id = :artist_id");
    queryartist.bindValue(":artist_id", artistId);

    if (!queryartist.exec()) {
        QMessageBox::critical(this, "Error", "Failed to execute procedure: " + queryartist.lastError().text());
        return;
    }

    QString artistDetails;
    bool hasResults = false;

    while (queryartist.next()) {
        hasResults = true;
        int birthYear = queryartist.value("BirthYear").toInt();
        QString artName = queryartist.value("Art Name").toString();
        artistDetails += QString("Artist Birth Year: %1\nArt Name: %2\n\n").arg(birthYear).arg(artName);
        ui->artname->setText(artName);
        ui->birthdate->setText(QString("Artist Birth Year: %1").arg(birthYear));
    }

    if (!hasResults) {
        artistDetails = "No artist details found.";
    }

}

void User::onSingerButtonClicked()
{
    QPushButton *button = qobject_cast<QPushButton *>(sender());
    if (!button) return;

    int singerID = button->property("ID").toInt();
    QString singerName = button->property("name").toString();
    getArtistDetails(singerID);
    ui->stackedWidget->setCurrentIndex(11);

    QSqlQuery songQuery;
    songQuery.prepare("{CALL GetSongsNamesByArtist(?)}");
    songQuery.addBindValue(singerID);

    if (!songQuery.exec()) {
        QMessageBox::critical(this, "Error", "Failed to execute stored procedure: " + songQuery.lastError().text());
        return;
    }

    QWidget *songContentWidget = new QWidget(this);
    QVBoxLayout *songLayout = new QVBoxLayout(songContentWidget);

    while (songQuery.next()) {
        int songId = songQuery.value(0).toInt();
        QString songTitle = songQuery.value(1).toString();

        QHBoxLayout *hLayout = new QHBoxLayout();

        QLabel *label = new QLabel(songContentWidget);
        QPixmap pixmap(":/new/prefix1/spotify logo.png");
        pixmap = pixmap.scaled(100, 100, Qt::KeepAspectRatio);
        label->setPixmap(pixmap);
        label->setFixedSize(150, 150);
        hLayout->addWidget(label);

        QPushButton *songButton = new QPushButton(songTitle, songContentWidget);
        songButton->setProperty("ID", songId);
        songButton->setProperty("name", songTitle);
        songButton->setProperty("pic_path", ":/new/prefix1/spotify logo.png");
        songButton->setStyleSheet(QPushButtonStyle);

        connect(songButton, &QPushButton::clicked, [this, songId]() {
            onSongButtonClicked2(songId);
        });

        songButton->setFixedSize(200, 100);

        QSizePolicy policy(QSizePolicy::Fixed, QSizePolicy::Fixed);
        policy.setHeightForWidth(true);
        songButton->setSizePolicy(policy);

        hLayout->addWidget(songButton);
        songLayout->addLayout(hLayout);
    }

    ui->scrollArea_16->setWidget(songContentWidget);

    QSqlQuery albumQuery;
    albumQuery.prepare("{CALL GetAlbumsNamesByArtist(?)}");
    albumQuery.addBindValue(singerID);

    if (!albumQuery.exec()) {
        QMessageBox::critical(this, "Error", "Failed to execute stored procedure: " + albumQuery.lastError().text());
        return;
    }

    QWidget *albumContentWidget = new QWidget(this);
    QVBoxLayout *albumLayout = new QVBoxLayout(albumContentWidget);

    while (albumQuery.next()) {
        int albumId = albumQuery.value(0).toInt();
        QString albumTitle = albumQuery.value(1).toString();

        QString connectionName = "getAlbumDetailsConnection";
        QSqlDatabase db = createDatabaseConnection(connectionName);

        if (!db.isOpen()) {
            QMessageBox::critical(this, "Database Error", "Failed to open database connection.");
            return;
        }

        QSqlQuery albumDetailsQuery(db);
        albumDetailsQuery.prepare("{ CALL GetAlbumDetails(:album_id) }");
        albumDetailsQuery.bindValue(":album_id", albumId);

        if (!albumDetailsQuery.exec()) {
            QMessageBox::critical(this, "Error", "Failed to execute stored procedure: " + albumDetailsQuery.lastError().text());
            db.close();
            QSqlDatabase::removeDatabase(connectionName);
            return;
        }
        if (albumDetailsQuery.next()) {
            QString releaseDate = albumDetailsQuery.value("release_date").toString();
            QString genre = albumDetailsQuery.value("genre").toString();
            QString zone = albumDetailsQuery.value("zone").toString();
            QString ageCategory = albumDetailsQuery.value("age_category").toString();

            QHBoxLayout *hLayout = new QHBoxLayout();

            QLabel *label = new QLabel(albumContentWidget);
            QPixmap pixmap(":/new/prefix1/spotify logo.png");
            pixmap = pixmap.scaled(100, 100, Qt::KeepAspectRatio);
            label->setPixmap(pixmap);
            label->setFixedSize(150, 150);
            hLayout->addWidget(label);

            QWidget *albumDetailsWidget = new QWidget(albumContentWidget);
            QVBoxLayout *albumDetailsLayout = new QVBoxLayout(albumDetailsWidget);

            QLabel *releaseDateLabel = new QLabel("Release Date: " + releaseDate, albumDetailsWidget);
            albumDetailsLayout->addWidget(releaseDateLabel);

            QLabel *genreLabel = new QLabel("Genre: " + genre, albumDetailsWidget);
            albumDetailsLayout->addWidget(genreLabel);

            QLabel *zoneLabel = new QLabel("Zone: " + zone, albumDetailsWidget);
            albumDetailsLayout->addWidget(zoneLabel);

            QLabel *ageCategoryLabel = new QLabel("Age Category: " + ageCategory, albumDetailsWidget);
            albumDetailsLayout->addWidget(ageCategoryLabel);

            hLayout->addWidget(albumDetailsWidget);

            QPushButton *albumButton = new QPushButton(albumTitle, albumContentWidget);
            albumButton->setProperty("ID", albumId);
            albumButton->setProperty("name", albumTitle);
            albumButton->setProperty("pic_path", ":/new/prefix1/spotify logo.png");

            connect(albumButton, &QPushButton::clicked, [this, albumId]() {
                onAlbumsingerButtonClicked(albumId);
            });

            albumButton->setFixedSize(250, 100);

            QSizePolicy policy(QSizePolicy::Fixed, QSizePolicy::Fixed);
            policy.setHeightForWidth(true);
            albumButton->setSizePolicy(policy);

            hLayout->addWidget(albumButton);

            QPushButton *commentButton = new QPushButton("Comment", albumContentWidget);
            commentButton->setProperty("ID", albumId);
            commentButton->setProperty("AlbumTitle", albumTitle);

            connect(commentButton, &QPushButton::clicked, this, &User::onCommentButtonClicked);
            commentButton->setStyleSheet(QPushButtonStyle);
            hLayout->addWidget(commentButton);

            QPushButton *likeButton = new QPushButton("Like", albumContentWidget);
            likeButton->setProperty("ID", albumId);

            connect(likeButton, &QPushButton::clicked, this, &User::onLikeAlbumButtonClicked);
            likeButton->setStyleSheet(QPushButtonStyle);
            hLayout->addWidget(likeButton);

            albumLayout->addLayout(hLayout);
        }
    }

    ui->scrollArea_17->setWidget(albumContentWidget);
}


void User::onLikeAlbumButtonClicked()
{
    QObject *senderObj = sender(); // Get the sender object
    if (senderObj)
    {
        if (!db.isOpen()) {
            QMessageBox::critical(this, "Database Error", "Failed to open database connection.");
            return;
        }
        int albumID = senderObj->property("albumID").toInt();
        if (!db.isOpen()) {
            QMessageBox::critical(this, "Error", "Database is not open.");
            return;
        }

        QSqlQuery query(db);
        query.prepare("EXEC PremiumUserLikeAlbum @UserID = :user_id, @AlbumID = :album_id");
        query.bindValue(":user_id", UserID);
        query.bindValue(":album_id", albumID);

        if (!query.exec()) {
            QMessageBox::critical(this, "Error", "Failed to like album: " + query.lastError().text());
            return;
        }

        QString resultMessage;
        while (query.next()) {
            resultMessage = query.value(0).toString();
        }

        if (resultMessage.contains("successfully")) {
            QMessageBox::information(this, "Success", resultMessage);
        } else if (resultMessage.contains("Only Premium users can like albums")) {
            QMessageBox::warning(this, "Warning", resultMessage);
        } else {
            QMessageBox::information(this, "Info", "No specific message returned.");
        }
    }
}
void User::onCommentButtonClicked()
{
    QPushButton *button = qobject_cast<QPushButton*>(sender());
    if (button) {
        QString albumID = button->property("ID").toString(); ////////////////////////
        QString albumName = button->property("AlbumTitle").toString();
        int userID = UserID;  // Set the user ID (replace with actual user ID logic)

        // Create a dialog for entering the comment
        QDialog *commentDialog = new QDialog(this);
        commentDialog->setWindowTitle("Enter Comment");

        QVBoxLayout *dialogLayout = new QVBoxLayout(commentDialog);

        QLabel *label = new QLabel("Enter your comment for : " + albumName, commentDialog); //////////////
        dialogLayout->addWidget(label);

        QTextEdit *commentTextEdit = new QTextEdit(commentDialog);
        dialogLayout->addWidget(commentTextEdit);

        QHBoxLayout *buttonsLayout = new QHBoxLayout();

        QPushButton *okButton = new QPushButton("OK", commentDialog);
        connect(okButton, &QPushButton::clicked, [this, commentDialog, commentTextEdit, userID, albumID]() {
            QString comment = commentTextEdit->toPlainText();

            QSqlQuery query;
            query.prepare("EXEC AddAlbumComment :UserID, :AlbumID, :Text");
            query.bindValue(":UserID", userID);
            query.bindValue(":AlbumID", albumID.toInt());
            query.bindValue(":Text", comment);

            if (query.exec()) {
                if (query.next()) {
                    QString message = query.value(0).toString();
                    QMessageBox::information(this, "Result", message);
                }
            } else {
                QMessageBox::critical(this, "Error", "Failed to execute query: " + query.lastError().text());
            }

            commentDialog->accept();
        });
        buttonsLayout->addWidget(okButton);

        QPushButton *cancelButton = new QPushButton("Cancel", commentDialog);
        connect(cancelButton, &QPushButton::clicked, commentDialog, &QDialog::reject);
        buttonsLayout->addWidget(cancelButton);

        dialogLayout->addLayout(buttonsLayout);

        commentDialog->setLayout(dialogLayout);
        commentDialog->exec();
    }
}
void User::onAlbumsingerButtonClicked(int albumId)
{
    ui->stackedWidget->setCurrentIndex(3);

    QWidget *contentWidget = new QWidget(this);
    QVBoxLayout *layout = new QVBoxLayout(contentWidget);

    // Prepare to call the stored procedure GetMusicNamesByAlbum
    QSqlQuery query;
    query.prepare("{ CALL GetMusicNamesByAlbum(:album_id) }");
    query.bindValue(":album_id", albumId);

    if (!query.exec()) {
        QMessageBox::critical(this, "Error", "Failed to execute stored procedure: " + query.lastError().text());
        return;
    }

    // Check if the query returned any results
    if (!query.next()) {
        QMessageBox::information(this, "No Data", "No music found for this album ID.");
        return;
    }

    // Process and display the results
    do {
        int musicId = query.value(0).toInt();
        QString musicTitle = query.value(1).toString();

        QHBoxLayout *hLayout = new QHBoxLayout();

        QLabel *label = new QLabel(contentWidget);
        QPixmap pixmap(":/new/prefix1/spotify logo.png");
        pixmap = pixmap.scaled(150, 150, Qt::KeepAspectRatio);
        label->setPixmap(pixmap);
        label->setFixedSize(200, 200);
        hLayout->addWidget(label);

        QPushButton *songButton = new QPushButton(musicTitle, contentWidget);
        songButton->setProperty("ID", musicId);
        songButton->setProperty("name", musicTitle);
        songButton->setProperty("pic_path", ":/new/prefix1/spotify logo.png");

        songButton->setFixedSize(400, 100);

        QSizePolicy policy(QSizePolicy::Fixed, QSizePolicy::Fixed);
        policy.setHeightForWidth(true);
        songButton->setSizePolicy(policy);

        hLayout->addWidget(songButton);
        layout->addLayout(hLayout);

        connect(songButton, &QPushButton::clicked, [this, musicId]() {
            onSongButtonClicked2(musicId);
        });
    } while (query.next());

    ui->scrollArea_3->setWidget(contentWidget);
}

void User::onSongOfAlbumButtonClicked() {
    QPushButton *button = qobject_cast<QPushButton*>(sender());
    if (button) {
        QString songName = button->property("name").toString();
        QString picPath = button->property("pic_path").toString();
        // Here you can handle the click event, e.g., show the picture in a larger view
        qDebug() << "Song button clicked: " << songName << " - Image path: " << picPath;

        ui->stackedWidget->setCurrentIndex(3);


        ///////////   full this page with songs of playlists

        QWidget *contentWidget = new QWidget(this);
        QVBoxLayout *layout = new QVBoxLayout(contentWidget);

        // Example songs
        for (int i = 1; i <= 100; ++i)
        {
            QHBoxLayout *hLayout = new QHBoxLayout();

            // Create label for song image
            QLabel *label = new QLabel(contentWidget);
            QPixmap pixmap(":/new/prefix1/spotify logo.png");
            pixmap = pixmap.scaled(150, 150, Qt::KeepAspectRatio);
            // Adjust size to fit within QLabel
            label->setPixmap(pixmap);
            label->setFixedSize(200, 200);
            hLayout->addWidget(label);

            // Create button for song name
            QPushButton *songButton = new QPushButton("Music " + QString::number(i), contentWidget);
            songButton->setProperty("ID", QString::number(i)); // Assuming songID is the same as i for this example
            songButton->setProperty("name", "Song " + QString::number(i));
            songButton->setProperty("pic_path", ":/new/prefix1/spotify logo.png");

            // connect(songButton, &QPushButton::clicked, this, &User::onSongButtonClicked);

            songButton->setFixedSize(400, 100); // Set fixed size for square shape

            // Ensure the button keeps the square shape
            QSizePolicy policy(QSizePolicy::Fixed, QSizePolicy::Fixed);
            policy.setHeightForWidth(true);
            songButton->setSizePolicy(policy);

            hLayout->addWidget(songButton);
            layout->addLayout(hLayout);
        }

        ui->scrollArea_3->setWidget(contentWidget);

    }
}

void User::onSongsingerButtonClicked()
{
    ui->stackedWidget->setCurrentIndex(9);
}


//------------------------------------------------------------ Singer's option ------------------------------------------------------------

void User::on_addmusicpushButton_clicked()
{
    clearScrollArea(ui->allsongsfordeleteScrollArea);
    clearScrollArea(ui->allalbumsfordeleteScrollArea);
    clearScrollArea(ui->allconcertsfordeleteScrollArea);
    ui->stackedWidget->setCurrentIndex(5);
    ui->tabWidget->setCurrentIndex(0);
    ui->tabWidget->setTabText(0, "Add music");
    ui->tabWidget->setTabText(1, "Add Album");
    ui->tabWidget->setTabText(2, "Delete music");
    ui->tabWidget->setTabText(3, "Delete Album");
    ui->tabWidget->setTabText(4, "Add Concert");
    ui->tabWidget->setTabText(5, "Delete Concert");

    for (int i = 0; i < 60; ++i) {
        ui->second->addItem(QString::number(i));
    }

    for (int i = 0; i < 60; ++i) {
        ui->minute->addItem(QString::number(i));
    }


    for (int i = 0; i < 24; ++i) {
        ui->hour->addItem(QString::number(i));
    }

    QStringList ageCategories = {"A", "B", "C"};
    for (const QString &category : ageCategories) {
        ui->agecategory->addItem(category);
    }
    for (const QString &category : ageCategories) {
        ui->agecategory2->addItem(category);
    }

    int currentYear = QDate::currentDate().year();

    // Populate combo box with years from 1900 to current year
    for (int year = 2000; year <= currentYear; ++year) {
        ui->yearconcert->addItem(QString::number(year));
    }
    // Populate months
    QStringList months = {"January", "February", "March", "April", "May", "June",
                          "July", "August", "September", "October", "November", "December"};

    ui->monthconcert->addItems(months);
    QStringList days;
    for (int i = 1; i <= 31; ++i) {
        days << QString::number(i);
    }

    ui->dayconcert->addItems(days);

    for (int i = 0; i < 60; ++i) {
        ui->minuteconcert->addItem(QString::number(i));
    }


    for (int i = 0; i < 24; ++i) {
        ui->hourconcert->addItem(QString::number(i));
    }

    /////////////////////////////////////////////////////////// full deletemusics' scroll with all songs

    // Check database connection and open if not open
    if (!db.isOpen()) {
        if (!db.open()) {
            QMessageBox::critical(this, "Database Error", "Failed to open the database: " + db.lastError().text());
            return;
        }
    }

    // Prepare the query to call the stored procedure GetSongsNamesByArtist
    QSqlQuery query;
    query.prepare("EXEC GetSongsNamesByArtist :artist_id");
    query.bindValue(":artist_id", UserID);


    // Execute the query
    if (!query.exec()) {
        qDebug() << "GetSongsNamesByArtist stored procedure error:" << query.lastError();
        QMessageBox::critical(this, "Error", "Failed to load songs: " + query.lastError().text());
        return;
    }


    QWidget *contentWidget = new QWidget(this);
    QVBoxLayout *layout = new QVBoxLayout(contentWidget);

    // Loop through the results
    while (query.next()) {
        int songID = query.value(0).toInt();
        QString songTitle = query.value(1).toString();

        QHBoxLayout *hLayout = new QHBoxLayout();

        // Create label for song image
        QLabel *label = new QLabel(contentWidget);
        QPixmap pixmap(":/new/prefix1/spotify logo.png");
        pixmap = pixmap.scaled(150, 150, Qt::KeepAspectRatio);
        label->setPixmap(pixmap);
        label->setFixedSize(200, 200);
        hLayout->addWidget(label);

        // Create button for song name
        QPushButton *songButton = new QPushButton(songTitle, contentWidget);
        songButton->setProperty("ID", songID);
        songButton->setProperty("name", songTitle);
        songButton->setProperty("pic_path", ":/new/prefix1/spotify logo.png");
        songButton->setStyleSheet(QPushButtonStyle);

        // Create delete button for the song
        QPushButton *deleteButton = new QPushButton("Delete", contentWidget);
        deleteButton->setProperty("ID", songID);
        deleteButton->setStyleSheet(QPushButtonStyle);
        // Connect the delete button to its slot
        connect(deleteButton, &QPushButton::clicked, [this, songID]() {
            deleteSong(songID);
        });

        songButton->setFixedSize(400, 100);
        deleteButton->setFixedSize(100, 50);

        QSizePolicy policy(QSizePolicy::Fixed, QSizePolicy::Fixed);
        policy.setHeightForWidth(true);
        songButton->setSizePolicy(policy);
        deleteButton->setSizePolicy(policy);

        hLayout->addWidget(songButton);
        hLayout->addWidget(deleteButton);
        layout->addLayout(hLayout);
    }

    ui->allsongsfordeleteScrollArea->setWidget(contentWidget);

    /////////////////////////////////////////////////////////// full deletemusics' scroll with all albums
    QSqlQuery query1(db);
    query1.prepare("EXEC GetAlbumsNamesByArtist :artist_id");
    query1.bindValue(":artist_id", UserID);

    if (!query1.exec()) {
        qDebug() << "GetAlbumsNamesByArtist stored procedure error:" << query1.lastError();
        QMessageBox::critical(this, "Error", "Failed to load albums: " + query1.lastError().text());
        return;
    }

    QWidget *contentWidget2 = new QWidget(this);
    QVBoxLayout *layout2 = new QVBoxLayout(contentWidget2);

    while (query1.next()) {
        int albumID = query1.value("album_id").toInt();
        QString albumTitle = query1.value("album_title").toString();

        QHBoxLayout *hLayout2 = new QHBoxLayout();

        // Create label for album image
        QLabel *label2 = new QLabel(contentWidget2);
        QPixmap pixmap2(":/new/prefix1/spotify logo.png");
        pixmap2 = pixmap2.scaled(150, 150, Qt::KeepAspectRatio);
        label2->setPixmap(pixmap2);
        label2->setFixedSize(200, 200);
        hLayout2->addWidget(label2);

        // Create button for album name
        QPushButton *albumButton2 = new QPushButton(albumTitle, contentWidget2);
        albumButton2->setProperty("ID", albumID);
        albumButton2->setProperty("name", albumTitle);
        albumButton2->setProperty("pic_path", ":/new/prefix1/spotify logo.png");
        albumButton2->setStyleSheet(QPushButtonStyle);

        // Create delete button for the album
        QPushButton *deleteButton2 = new QPushButton("Delete", contentWidget2);
        deleteButton2->setProperty("ID", albumID);
        deleteButton2->setStyleSheet(QPushButtonStyle);
        // Connect the delete button to its slot
        connect(deleteButton2, &QPushButton::clicked, [this, albumID]() {
            deleteAlbum(albumID);
        });

        albumButton2->setFixedSize(400, 100);
        deleteButton2->setFixedSize(100, 50);

        QSizePolicy policy2(QSizePolicy::Fixed, QSizePolicy::Fixed);
        policy2.setHeightForWidth(true);
        albumButton2->setSizePolicy(policy2);
        deleteButton2->setSizePolicy(policy2);

        hLayout2->addWidget(albumButton2);
        hLayout2->addWidget(deleteButton2);
        layout2->addLayout(hLayout2);
    }

    ui->allalbumsfordeleteScrollArea->setWidget(contentWidget2);


    /////////////////////////////////////////////////////////// full deletemusics' scroll with all concerts
    QList<QMap<QString, QString>> concertDetailsList = getArtistConcertDetails(UserID, db);

    QWidget *contentWidget3 = new QWidget(ui->allconcertsfordeleteScrollArea);
    QVBoxLayout *layout3 = new QVBoxLayout(contentWidget3);

    for (const QMap<QString, QString>& concertDetails : concertDetailsList) {
        QHBoxLayout *hLayout = new QHBoxLayout();

        // Create button for concert location
        QPushButton *locationButton = new QPushButton(concertDetails["location"], contentWidget3);
        locationButton->setFixedSize(250, 50);
        locationButton->setStyleSheet(QPushButtonStyle);
        hLayout->addWidget(locationButton);

        // Create label for concert date
        QLabel *dateLabel = new QLabel(concertDetails["concert_date"], contentWidget3);
        dateLabel->setFixedSize(250, 50);
        hLayout->addWidget(dateLabel);

        // Create label for concert status
        QLabel *statusLabel = new QLabel(concertDetails["concert_status"], contentWidget3);
        statusLabel->setFixedSize(250, 50);
        hLayout->addWidget(statusLabel);

        // Create delete button for the concert
        QPushButton *deleteButton = new QPushButton("Cancel", contentWidget3);
        deleteButton->setProperty("ID", concertDetails["concert_id"]);
        deleteButton->setStyleSheet(QPushButtonStyle);
        // Capture 'this' in the lambda function
        connect(deleteButton, &QPushButton::clicked, [this, concertID = concertDetails["concert_id"].toInt()]() {
            deleteConcert(concertID);
        });
        hLayout->addWidget(deleteButton);

        layout3->addLayout(hLayout);
    }

    // Set the new content widget in the scroll area
    ui->allconcertsfordeleteScrollArea->setWidget(contentWidget3);
}


//    // Full this page with all concerts
//    QWidget *contentWidget3 = new QWidget(this);
//    QVBoxLayout *layout3 = new QVBoxLayout(contentWidget3);

//    // Example concerts
//    for (int i = 1; i <= 100; ++i)
//    {
//        QHBoxLayout *hLayout3 = new QHBoxLayout();

//        // Create button for concert location (Push button)
//        QPushButton *locationButton = new QPushButton("Location " + QString::number(i), contentWidget3);
//        locationButton->setFixedSize(250, 50);
//        locationButton->setStyleSheet(QPushButtonStyle);
//        hLayout3->addWidget(locationButton);

//        // Create label for concert date
//        QLabel *dateLabel = new QLabel("Date " + QString::number(i), contentWidget3);
//        dateLabel->setFixedSize(250, 50);
//        hLayout3->addWidget(dateLabel);

//        // Create label for concert status
//        QLabel *statusLabel = new QLabel("Concert Status", contentWidget3);
//        statusLabel->setFixedSize(250, 50);
//        hLayout3->addWidget(statusLabel);

//        layout3->addLayout(hLayout3);
//    }

//    ui->allconcertsfordeleteScrollArea->setWidget(contentWidget3);


void User::deleteConcert(int concertID)
{
    QSqlQuery query(db); // Assuming db is your database connection
    query.prepare("EXEC CancelConcertByArtist @concert_id = :concert_id");
    query.bindValue(":concert_id", concertID);

    if (!query.exec()) {
        QMessageBox::critical(nullptr, "Database Error", query.lastError().text());
        return;
    }

    // Process the result
    if (query.next()) {
        QString message = query.value("Message").toString();
        QMessageBox::information(nullptr, "Concert Cancellation", message);
    } else {
        QMessageBox::warning(nullptr, "Concert Cancellation", "No message returned from the stored procedure.");
    }
}



void User::deleteAlbum(int albumID)
{
    if (!db.isOpen()) {
        QMessageBox::critical(this, "Error", "Database is not open.");
        return;
    }

    QSqlQuery query(db);
    query.prepare("EXEC RemoveAlbum @AlbumID = :AlbumID");
    query.bindValue(":AlbumID", albumID);

    if (!query.exec()) {
        qDebug() << "RemoveAlbum stored procedure error:" << query.lastError();
        QMessageBox::critical(this, "Error", "Failed to delete album: " + query.lastError().text());
        return;
    }

    QMessageBox::information(this, "Success", "Album deleted successfully.");


}

void User::deleteSong(int songID)
{
    // Check database connection and open if not open
    if (!db.isOpen()) {
        if (!db.open()) {
            QMessageBox::critical(this, "Database Error", "Failed to open the database: " + db.lastError().text());
            return;
        }
    }

    // Prepare the query to call the stored procedure RemoveSong
    QSqlQuery query(db); // Make sure to pass the database connection
    query.prepare("EXEC RemoveSong :MusicID");
    query.bindValue(":MusicID", songID);

    // Execute the query
    if (!query.exec()) {
        qDebug() << "RemoveSong stored procedure error:" << query.lastError();
        QMessageBox::critical(this, "Error", "Failed to delete song: " + query.lastError().text());
        return;
    }

    // Fetch the result message from the stored procedure
    if (query.next()) {
        QString resultMessage = query.value(0).toString();
        if (resultMessage.startsWith("Success")) {
            QMessageBox::information(this, "Success", resultMessage);
        } else {
            QMessageBox::warning(this, "Error", resultMessage);
        }
    } else {
        QMessageBox::warning(this, "Error", "No result returned from the stored procedure.");
    }
}

QWidget *contentWidget;
void User::on_confirmButton_clicked()
{
    bool ok;
    int numSongs = ui->numberOfSongsLineEdit->text().toInt(&ok);

    if (!ok || numSongs <= 0) {
        // Handle invalid input
        QMessageBox::warning(this, "Invalid Input", "Please enter a valid number of songs.");
        return;
    }

    contentWidget = new QWidget(this);
    QVBoxLayout *layout = new QVBoxLayout(contentWidget);

    // Create song input fields dynamically
    for (int i = 0; i < numSongs; ++i) {
        QHBoxLayout *hLayout = new QHBoxLayout();

        // Title
        QLineEdit *titleLineEdit = new QLineEdit(contentWidget);
        titleLineEdit->setObjectName("titleLineEdit" + QString::number(i));
        titleLineEdit->setPlaceholderText("Title");
        hLayout->addWidget(titleLineEdit);

        // Duration (hour, minute, second)
        QComboBox *hourComboBox = new QComboBox(contentWidget);
        hourComboBox->setObjectName("hourComboBox" + QString::number(i));
        for (int j = 0; j < 24; ++j) {
            hourComboBox->addItem(QString::number(j));
        }
        hLayout->addWidget(hourComboBox);

        QComboBox *minuteComboBox = new QComboBox(contentWidget);
        minuteComboBox->setObjectName("minuteComboBox" + QString::number(i));
        for (int j = 0; j < 60; ++j) {
            minuteComboBox->addItem(QString::number(j));
        }
        hLayout->addWidget(minuteComboBox);

        QComboBox *secondComboBox = new QComboBox(contentWidget);
        secondComboBox->setObjectName("secondComboBox" + QString::number(i));
        for (int j = 0; j < 60; ++j) {
            secondComboBox->addItem(QString::number(j));
        }
        hLayout->addWidget(secondComboBox);

        // Genre
        QLineEdit *genreLineEdit = new QLineEdit(contentWidget);
        genreLineEdit->setObjectName("genreLineEdit" + QString::number(i));
        genreLineEdit->setPlaceholderText("Genre");
        hLayout->addWidget(genreLineEdit);

        // Zone
        QLineEdit *zoneLineEdit = new QLineEdit(contentWidget);
        zoneLineEdit->setObjectName("zoneLineEdit" + QString::number(i));
        zoneLineEdit->setPlaceholderText("Zone");
        hLayout->addWidget(zoneLineEdit);

        // Age Category
        QComboBox *ageCategoryComboBox = new QComboBox(contentWidget);
        ageCategoryComboBox->setObjectName("ageCategoryComboBox" + QString::number(i));
        ageCategoryComboBox->addItems({"A", "B", "C"});
        hLayout->addWidget(ageCategoryComboBox);

        // Can Add to Playlist
        QCheckBox *canAddToPlaylistCheckBox = new QCheckBox("Can add to playlist", contentWidget);
        canAddToPlaylistCheckBox->setObjectName("canAddToPlaylistCheckBox" + QString::number(i));
        hLayout->addWidget(canAddToPlaylistCheckBox);

        // Lyrics Text
        QLineEdit *lyricsLineEdit = new QLineEdit(contentWidget);
        lyricsLineEdit->setObjectName("lyricsLineEdit" + QString::number(i));
        lyricsLineEdit->setPlaceholderText("Lyrics");
        hLayout->addWidget(lyricsLineEdit);

        layout->addLayout(hLayout);
    }

    // Set the content widget as the scroll area's widget
    ui->songsScrollArea->setWidget(contentWidget);
}

QDate convertToDate(int day, const QString& monthName, int year) {
    static const QMap<QString, int> monthMap = {
        {"January", 1}, {"February", 2}, {"March", 3},
        {"April", 4}, {"May", 5}, {"June", 6},
        {"July", 7}, {"August", 8}, {"September", 9},
        {"October", 10}, {"November", 11}, {"December", 12}
    };

    int month = monthMap.value(monthName, -1);
    if (month == -1) {
        // Handle invalid month name if necessary
        qWarning() << "Invalid month name:" << monthName;
        return QDate(); // Return an invalid QDate
    }

    return QDate(year, month, day);
}

void User::on_okaddalbumpushButton_clicked() {
    // Get album details from UI elements
    QString albumTitle = ui->title_4->text();
    QString albumZone = ui->zone_2->text();
    QString albumGenre = ui->genre_2->text();
    QString albumAgeCategory = ui->agecategory2->currentText();
    int artistID = UserID;

    // Validate album details
    if (albumTitle.isEmpty() || albumZone.isEmpty() || albumGenre.isEmpty() || albumAgeCategory.isEmpty()) {
        QMessageBox::critical(this, "Input Error", "All album fields must be filled.");
        return;
    }

    int numSongs = ui->numberOfSongsLineEdit->text().toInt();
    if (numSongs <= 0) {
        QMessageBox::critical(this, "Input Error", "The number of songs must be greater than 0.");
        return;
    }

    // Validate song details
    for (int i = 0; i < numSongs; ++i) {
        QLineEdit *titleLineEdit = findChild<QLineEdit*>("titleLineEdit" + QString::number(i));
        QComboBox *hourComboBox = findChild<QComboBox*>("hourComboBox" + QString::number(i));
        QComboBox *minuteComboBox = findChild<QComboBox*>("minuteComboBox" + QString::number(i));
        QComboBox *secondComboBox = findChild<QComboBox*>("secondComboBox" + QString::number(i));
        QLineEdit *genreLineEdit = findChild<QLineEdit*>("genreLineEdit" + QString::number(i));
        QLineEdit *zoneLineEdit = findChild<QLineEdit*>("zoneLineEdit" + QString::number(i));
        QComboBox *ageCategoryComboBox = findChild<QComboBox*>("ageCategoryComboBox" + QString::number(i));
        QCheckBox *canAddToPlaylistCheckBox = findChild<QCheckBox*>("canAddToPlaylistCheckBox" + QString::number(i));
        QLineEdit *lyricsLineEdit = findChild<QLineEdit*>("lyricsLineEdit" + QString::number(i));

        if (titleLineEdit->text().isEmpty() ||
                hourComboBox->currentText().isEmpty() ||
                minuteComboBox->currentText().isEmpty() ||
                secondComboBox->currentText().isEmpty() ||
                genreLineEdit->text().isEmpty() ||
                zoneLineEdit->text().isEmpty() ||
                ageCategoryComboBox->currentText().isEmpty() ||
                lyricsLineEdit->text().isEmpty()) {
            QMessageBox::critical(this, "Input Error", "All fields for each song must be filled.");
            return;
        }
    }


    // Start a transaction
    QSqlQuery query;
    if (!query.exec("BEGIN TRANSACTION")) {
        QMessageBox::critical(this, "Transaction Error", query.lastError().text());
        db.close();
        return;
    }

    // Prepare the query for the stored procedure
    query.prepare("{CALL AddNewAlbum(?, ?, ?, ?, ?)}");
    query.bindValue(0, albumTitle);
    query.bindValue(1, albumGenre);
    query.bindValue(2, albumZone);
    query.bindValue(3, albumAgeCategory);
    query.bindValue(4, artistID);

    if (!query.exec()) {
        QMessageBox::critical(this, "Query Error", query.lastError().text());
        query.exec("ROLLBACK");
        db.close();
        return;
    }

    // Get the new album ID and message
    int albumID = -1;
    QString message;
    if (query.next()) {
        albumID = query.value(0).toInt();
        message = query.value(1).toString();
    } else {
        QMessageBox::critical(this, "Error", "Failed to retrieve album ID.");
        query.exec("ROLLBACK");
        db.close();
        return;
    }

    if (albumID == -1) {
        QMessageBox::critical(this, "Error", message);
        query.exec("ROLLBACK");
        db.close();
        return;
    }

    // Prepare the song details insertion
    QSqlQuery songQuery(db);
    songQuery.prepare("{CALL AddNewMusic(?, ?, ?, ?, ?, ?, ?, ?, ?)}");

    for (int i = 0; i < numSongs; ++i) {
        QLineEdit *titleLineEdit = findChild<QLineEdit*>("titleLineEdit" + QString::number(i));
        QComboBox *hourComboBox = findChild<QComboBox*>("hourComboBox" + QString::number(i));
        QComboBox *minuteComboBox = findChild<QComboBox*>("minuteComboBox" + QString::number(i));
        QComboBox *secondComboBox = findChild<QComboBox*>("secondComboBox" + QString::number(i));
        QLineEdit *genreLineEdit = findChild<QLineEdit*>("genreLineEdit" + QString::number(i));
        QLineEdit *zoneLineEdit = findChild<QLineEdit*>("zoneLineEdit" + QString::number(i));
        QComboBox *ageCategoryComboBox = findChild<QComboBox*>("ageCategoryComboBox" + QString::number(i));
        QCheckBox *canAddToPlaylistCheckBox = findChild<QCheckBox*>("canAddToPlaylistCheckBox" + QString::number(i));
        QLineEdit *lyricsLineEdit = findChild<QLineEdit*>("lyricsLineEdit" + QString::number(i));

        QString title = titleLineEdit->text();
        QString duration = QString("%1:%2:%3").arg(hourComboBox->currentText(), minuteComboBox->currentText(), secondComboBox->currentText());
        QString genre = genreLineEdit->text();
        QString zone = zoneLineEdit->text();
        QString ageGroup = ageCategoryComboBox->currentText();
        bool canAddToPlaylist = canAddToPlaylistCheckBox->isChecked();
        QString lyrics = lyricsLineEdit->text();

        songQuery.bindValue(0, title);
        songQuery.bindValue(1, duration);
        songQuery.bindValue(2, genre);
        songQuery.bindValue(3, zone);
        songQuery.bindValue(4, ageGroup);
        songQuery.bindValue(5, canAddToPlaylist);
        songQuery.bindValue(6, lyrics);
        songQuery.bindValue(7, albumID);
        songQuery.bindValue(8, artistID);

        if (!songQuery.exec()) {
            QMessageBox::critical(this, "Song Insertion Error", songQuery.lastError().text());
            query.exec("ROLLBACK");
            db.close();
            return;
        }
    }

    // Commit the transaction
    if (!query.exec("COMMIT")) {
        QMessageBox::critical(this, "Commit Error", query.lastError().text());
        db.close();
        return;
    }

    QMessageBox::information(this, "Success", "Album and songs added successfully.");

}


void User::on_okaddalbum_clicked()
{
    // Retrieve album details from UI

}


void User::on_okaddmusic_clicked()
{

    QString title = ui->title->text();
    QString genre = ui->genre->text();
    QString zone = ui->zone->text();
    QString ageCategory = ui->agecategory->currentText();
    bool canAddToPlaylist = ui->checkBox->isChecked();
    QString lyrics = ui->plainTextEdit->toPlainText();
    int albumId = -1;
    int artistId = UserID;


    int hour = ui->hour->currentText().toInt();
    int minute = ui->minute->currentText().toInt();
    int second = ui->second->currentText().toInt();
    QTime duration(hour, minute, second);

    if (title.isEmpty() || genre.isEmpty() || artistId == 0) {
        QMessageBox::warning(this, "Input Error", "Please fill in all required fields.");
        return;
    }


    QSqlQuery query;
    query.prepare("{CALL AddNewMusic(?, ?, ?, ?, ?, ?, ?, ?, ?)}");

    query.addBindValue(title);
    query.addBindValue(duration);
    query.addBindValue(genre);
    query.addBindValue(zone.isEmpty() ? QVariant(QVariant::String) : zone);
    query.addBindValue(ageCategory.isEmpty() ? QVariant(QVariant::String) : ageCategory);
    query.addBindValue(canAddToPlaylist);
    query.addBindValue(lyrics);
    query.addBindValue(albumId == -1 ? QVariant(QVariant::Int) : albumId);
    query.addBindValue(artistId);

    if (!query.exec()) {
        qDebug() << "AddNewMusic stored procedure error:" << query.lastError();
        QMessageBox::critical(this, "Error", "Failed to add new music: " + query.lastError().text());
        return;
    }

    QMessageBox::information(this, "Success", "Music added successfully!");
    qDebug() << "Music added successfully!";
}


void User::on_okaddconcert_clicked()
{
    // Validate input fields
    if (ui->locationconcert->text().isEmpty() ||
            ui->priceregular->text().isEmpty() ||
            ui->numberregular->text().isEmpty() ||
            ui->pricevip->text().isEmpty() ||
            ui->numbervip->text().isEmpty() ||
            ui->pricepremium->text().isEmpty() ||
            ui->numberpremium->text().isEmpty() ||
            ui->yearconcert->currentText().isEmpty() ||
            ui->monthconcert->currentText().isEmpty() ||
            ui->dayconcert->currentText().isEmpty()) {
        QMessageBox::critical(nullptr, "Input Error", "Please fill in all fields.");
        return;
    }

    bool validYear, validDay;
    int year = ui->yearconcert->currentText().toInt(&validYear);
    int day = ui->dayconcert->currentText().toInt(&validDay);

    // Create a mapping of month names to month numbers
    QMap<QString, int> monthMap = {
        {"January", 1}, {"February", 2}, {"March", 3},
        {"April", 4}, {"May", 5}, {"June", 6},
        {"July", 7}, {"August", 8}, {"September", 9},
        {"October", 10}, {"November", 11}, {"December", 12}
    };

    // Retrieve the month name from the UI and convert it to the corresponding month number
    QString monthName = ui->monthconcert->currentText();
    int month = monthMap.value(monthName, -1); // Default to -1 if the month name is not found

    if (!validYear) {
        QMessageBox::critical(nullptr, "Input Error", "Invalid year provided.");
        return;
    }
    if (month == -1) {
        QMessageBox::critical(nullptr, "Input Error", "Invalid month provided.");
        return;
    }
    if (!validDay) {
        QMessageBox::critical(nullptr, "Input Error", "Invalid day provided.");
        return;
    }

    QDate concertDate(year, month, day);

    if (!concertDate.isValid()) {
        QMessageBox::critical(nullptr, "Input Error", "Invalid date provided.");
        return;
    }
    QString concertLocation = ui->locationconcert->text();
    double regularTicketPrice = ui->priceregular->text().toDouble();
    double vipTicketPrice = ui->pricevip->text().toDouble();
    double premiumTicketPrice = ui->pricepremium->text().toDouble();
    int numRegularTickets = ui->numberregular->text().toInt();
    int numVIPTickets = ui->numbervip->text().toInt();
    int numPremiumTickets = ui->numberpremium->text().toInt();

    QSqlQuery query(db);
    query.prepare("EXEC AddNewConcertWithTickets :ArtistID, :ConcertDate, :ConcertLocation, :RegularTicketPrice, :VIPTicketPrice, :PremiumTicketPrice, :NumRegularTickets, :NumVIPTickets, :NumPremiumTickets;");
    query.bindValue(":ArtistID", UserID);
    query.bindValue(":ConcertDate", concertDate.toString("yyyy-MM-dd"));  // Ensure this is correctly formatted as yyyy-MM-dd
    query.bindValue(":ConcertLocation", concertLocation);
    query.bindValue(":RegularTicketPrice", regularTicketPrice);
    query.bindValue(":VIPTicketPrice", vipTicketPrice);
    query.bindValue(":PremiumTicketPrice", premiumTicketPrice);
    query.bindValue(":NumRegularTickets", numRegularTickets);
    query.bindValue(":NumVIPTickets", numVIPTickets);
    query.bindValue(":NumPremiumTickets", numPremiumTickets);
    if (!query.exec()) {
        QMessageBox::critical(nullptr, "Database Error", query.lastError().text());
        return;
    }

    QMessageBox::information(nullptr, "Success", "Concert and tickets added successfully!");
}


QList<QMap<QString, QString>> getArtistConcertDetails(int artistID, QSqlDatabase& db) {
    QList<QMap<QString, QString>> concertDetailsList;

    QSqlQuery query(db);
    query.prepare("EXEC GetArtistConcertDetails @ArtistID = :ArtistID");
    query.bindValue(":ArtistID", artistID);

    if (!query.exec()) {
        QMessageBox::critical(nullptr, "Database Error", query.lastError().text());
        return concertDetailsList;
    }

    while (query.next()) {
        QMap<QString, QString> concertDetails;
        concertDetails["concert_id"] = query.value("concert_id").toString();
        concertDetails["location"] = query.value("location").toString();
        concertDetails["concert_date"] = query.value("concert_date").toString();
        concertDetails["concert_status"] = query.value("concert_status").toString();
        concertDetailsList.append(concertDetails);
    }

    return concertDetailsList;
}


//** baraye delete ha baiad Slot push button besazim

//------------------------------------------------------------ Song button slot ?????? -----------------------------------------------------------
void User::onSongButtonClicked2(int songID)
{
    qDebug() << "Clicked song ID:" << songID;

    // Check database connection and open if not open
    if (!db.isOpen()) {
        if (!db.open()) {
            QMessageBox::critical(this, "Database Error", "Failed to open the database: " + db.lastError().text());
            return;
        }
    }

    // Prepare the query to call the stored procedure GetSongDetails
    QSqlQuery query;
    query.prepare("EXEC GetSongDetails @music_id = :music_id");
    query.bindValue(":music_id", songID);
    MusicID=songID;

    // Execute the query
    if (!query.exec()) {
        qDebug() << "GetSongDetails stored procedure error:" << query.lastError();
        QMessageBox::critical(this, "Error", "Failed to load song details: " + query.lastError().text());
        return;
    }

    // Retrieve song details
    if (query.next()) {
        QString artistName = query.value("artist_name").toString();
        QString title = query.value("title").toString();
        QString duration = query.value("duration").toString();
        QString genre = query.value("genre").toString();
        QString zone = query.value("zone").toString();
        QString ageCategory = query.value("age_category").toString();
        QString lyrics = query.value("lyrics").toString();
        QString playlistStatus = query.value("playlist_status").toString();

        // Set the details in the UI
        ui->namesonglabel->setText(title);
        ui->singersonglabel->setText(artistName);
        ui->durationofsong->setText(duration);
        ui->genreofsong->setText(genre);
        ui->zoneofsong->setText(zone);
        ui->agecategoryofsong->setText(ageCategory);
        ui->textsongtTextEdit->setPlainText(lyrics);

        // Check playlist status
        bool canAddToPlaylist = (playlistStatus == "Can be added to playlist");
        ui->addtoplaylistpushButton->setEnabled(canAddToPlaylist);

        if (!canAddToPlaylist) {
            connect(ui->addtoplaylistpushButton, &QPushButton::clicked, this, [this]() {
                QMessageBox::warning(this, "Playlist Error", "This song cannot be added to the playlist.");
            });
        } else {
            disconnect(ui->addtoplaylistpushButton, nullptr, nullptr, nullptr); // Remove previous connections
            connect(ui->addtoplaylistpushButton, &QPushButton::clicked, this, &User::addToPlaylist); // Connect to your addToPlaylist function
        }

        // Show the song details page
        ui->stackedWidget->setCurrentIndex(9);
    } else {
        QMessageBox::warning(this, "Error", "Failed to retrieve song details.");
    }
}


void User::onSongButtonClicked()
{
    QPushButton *clickedButton = qobject_cast<QPushButton*>(sender());
    if (!clickedButton)
        return;


    QString songIDStr = clickedButton->property("ID").toString();
    MusicID=songIDStr.toInt();
    QString singerName = clickedButton->property("name").toString();

    int songID = songIDStr.toInt();

    qDebug() << "Clicked song ID:" << songID;
    qDebug() << "Singer name:" << singerName;

    // Check database connection and open if not open
    if (!db.isOpen()) {
        if (!db.open()) {
            QMessageBox::critical(this, "Database Error", "Failed to open the database: " + db.lastError().text());
            return;
        }
    }

    // Prepare the query to call the stored procedure GetSongDetails
    QSqlQuery query;
    query.prepare("EXEC GetSongDetails @music_id = :music_id");
    query.bindValue(":music_id", songID);

    // Execute the query
    if (!query.exec()) {
        qDebug() << "GetSongDetails stored procedure error:" << query.lastError();
        QMessageBox::critical(this, "Error", "Failed to load song details: " + query.lastError().text());
        return;
    }

    // Retrieve song details
    if (query.next()) {
        QString artistName = query.value("artist_name").toString();
        QString title = query.value("title").toString();
        QString duration = query.value("duration").toString();
        QString genre = query.value("genre").toString();
        QString zone = query.value("zone").toString();
        QString ageCategory = query.value("age_category").toString();
        QString lyrics = query.value("lyrics").toString();
        QString playlistStatus = query.value("playlist_status").toString();

        // Set the details in the UI
        ui->namesonglabel->setText(title);
        ui->singersonglabel->setText(artistName);
        ui->durationofsong->setText(duration);
        ui->genreofsong->setText(genre);
        ui->zoneofsong->setText(zone);
        ui->agecategoryofsong->setText(ageCategory);
        ui->textsongtTextEdit->setPlainText(lyrics);

        // Check playlist status
        bool canAddToPlaylist = (playlistStatus == "Can be added to playlist");
        ui->addtoplaylistpushButton->setEnabled(canAddToPlaylist);

        if (!canAddToPlaylist) {
            connect(ui->addtoplaylistpushButton, &QPushButton::clicked, this, [this]() {
                QMessageBox::warning(this, "Playlist Error", "This song cannot be added to the playlist.");
            });
        } else {
            disconnect(ui->addtoplaylistpushButton, nullptr, nullptr, nullptr); // Remove previous connections
            connect(ui->addtoplaylistpushButton, &QPushButton::clicked, this, &User::addToPlaylist); // Connect to your addToPlaylist function
        }

        // Connect the comment button signal and slot
        ui->commentpushButton->setProperty("musicID", songID);
        ui->commentpushButton->setProperty("musicName", title);
        connect(ui->commentpushButton, &QPushButton::clicked, this, &User::on_commentpushButton_clicked);
        // Show the song details page
        ui->stackedWidget->setCurrentIndex(9);
    } else {
        QMessageBox::warning(this, "Error", "Failed to retrieve song details.");
    }
}


void User::addToPlaylist()
{
    bool ok;
    // Implement the functionality to add the song to the playlist
    QString playlistName = QInputDialog::getText(this, tr("Add to Playlist"),
                                                 tr("Enter the name of the playlist:"), QLineEdit::Normal,
                                                 "", &ok);

    // Check if user pressed OK and entered a name
    if (ok) {
        if (!playlistName.isEmpty()) {

            // Prepare the SQL query to call the stored procedure
            QSqlQuery query;
            query.prepare("EXEC AddSongToPlaylist @user_id = :user_id, @playlist_name = :playlist_name, @music_id = :music_id");
            query.bindValue(":user_id", UserID);
            query.bindValue(":playlist_name", playlistName);
            query.bindValue(":music_id", MusicID);

            // Execute the query
            if (!query.exec()) {
                qDebug() << "Error executing stored procedure:" << query.lastError().text();
                // Handle error (e.g., display error message)
                QMessageBox::critical(this, "Error", "Failed to add song to playlist.");
                return;
            }

            // Process the results
            if (query.next()) {
                QString message = query.value(0).toString();
                QMessageBox::information(this, "Result", message);
            } else {
                QMessageBox::warning(this, "Error", "No message returned from the procedure.");
            }
        } else {
            // Notify user that the name cannot be empty
            QMessageBox::warning(this, tr("Invalid Input"), tr("The playlist name cannot be empty."));
        }
    }
}




//------------------------------------------------------------ Simple Slots ----------------------------------------------------------------------

void User::on_logout_clicked()
{
    refreshmainpage();
    sign *h = new sign(); // Replace PremiumMenu with your actual premium menu class
    h->show();
    this->close();


}
void User::on_cancle1_clicked()
{
    ui->stackedWidget->setCurrentIndex(0);
}
void User::on_cancle2_clicked()
{
    ui->stackedWidget->setCurrentIndex(0);
}
void User::on_cancle3_clicked()
{
    ui->stackedWidget->setCurrentIndex(0);
}
void User::on_cancle4_clicked()
{
    ui->stackedWidget->setCurrentIndex(0);
}
void User::on_cancle5_clicked()
{
    ui->stackedWidget->setCurrentIndex(0);
}
void User::on_cancle6_clicked()
{
    ui->stackedWidget->setCurrentIndex(0);
}
void User::on_cancle9_clicked()
{
    ui->stackedWidget->setCurrentIndex(0);
}
void User::on_cancle8_clicked()
{
    ui->stackedWidget->setCurrentIndex(0);
}
void User::on_cancle7_clicked()
{
    ui->stackedWidget->setCurrentIndex(0);
}
void User::on_cancle12_clicked()
{
    ui->stackedWidget->setCurrentIndex(0);
}
void User::on_cancle11_clicked()
{
    if(UserType=="Normal"){
        ui->stackedWidget->setCurrentIndex(10);
        return;
    }
    ui->stackedWidget->setCurrentIndex(0);
}
void User::on_cancle10_clicked()
{
    ui->stackedWidget->setCurrentIndex(0);
}
void User::on_cancle13_clicked()
{
    ui->stackedWidget->setCurrentIndex(0);
}
void User::on_cancle14_clicked()
{
    ui->stackedWidget->setCurrentIndex(0);
}
void User::on_cancle15_clicked()
{
    ui->stackedWidget->setCurrentIndex(0);
}
void User::on_cancle16_clicked()
{
    ui->stackedWidget->setCurrentIndex(0);
}
void User::on_cancle16_2_clicked()
{
    ui->stackedWidget->setCurrentIndex(0);
}
void User::on_cancle16_3_clicked()
{
    ui->stackedWidget->setCurrentIndex(0);
}
void User::on_cancle17_clicked()
{
    ui->stackedWidget->setCurrentIndex(0);
}
void User::on_cancle19_clicked()
{
    ui->stackedWidget->setCurrentIndex(0);
}
void User::on_cancle16_8_clicked()
{
    ui->stackedWidget->setCurrentIndex(0);
}

void User::on_cancle21_clicked()
{
    if(UserType=="Normal"){
        ui->stackedWidget->setCurrentIndex(10);
        return;
    }
    ui->stackedWidget->setCurrentIndex(0);
}

//------------------------------------------------------------ Main Song page ------------------------------------------------------------

void User::on_addtofavpushButton_clicked()
{
    // Prepare the SQL query to execute the stored procedure
    QSqlQuery query(db);
    query.prepare("EXEC AddToFavoriteSongs :user_id, :song_id");

    // Bind values to the query parameters
    query.bindValue(":user_id", UserID);
    query.bindValue(":song_id", MusicID);

    // Execute the query
    if (!query.exec()) {
        QMessageBox::critical(nullptr, "Database Error", query.lastError().text());
        db.close();
        return;
    }

    // Check for any returned messages from the stored procedure
    if (query.next()) {
        QString message = query.value(0).toString();

        if (message.startsWith("Error:")) {
            // Display the error message
            QMessageBox::critical(nullptr, "Procedure Error", message);
        } else {
            // If execution successful
            QMessageBox::information(nullptr, "Success", message);
        }
    }

}


void User::on_addtoplaylistpushButton_clicked()
{

}


/*void User::on_addtoplaylistpushButton_clicked()
{

    //////////////////////////////////////////////// for example ////////////////////////////////////
    // Show input dialog to get playlist name
        bool ok;
        QString playlistName = QInputDialog::getText(this, tr("Add to Playlist"),
                                                     tr("Enter the name of the playlist:"), QLineEdit::Normal,
                                                     "", &ok);
        // Check if user pressed OK and entered a name
       /* if (ok && !playlistName.isEmpty()) {
            // Add your logic to handle the addition of the song to the specified playlist
            // For example, you might execute a SQL query to add the song to the playlist in the database
            QSqlQuery query;
            query.prepare("INSERT INTO Playlists (name, user_id) VALUES (:name, :user_id)");
            query.bindValue(":name", playlistName);
            query.bindValue(":user_id", UserID); // Assuming you have a variable UserID for the current user

            if (!query.exec()) {
                QMessageBox::critical(this, "Error", "Failed to add to playlist: " + query.lastError().text());
                return;
            }

            // Notify user that the song was added to the playlist
            QMessageBox::information(this, tr("Success"), tr("The song has been added to the playlist '%1'.").arg(playlistName));
        }
        else if (ok && playlistName.isEmpty()) {
            // Notify user that the name cannot be empty
            QMessageBox::warning(this, tr("Invalid Input"), tr("The playlist name cannot be empty."));
        }*/



void User::on_commentpushButton_clicked()
{
    QPushButton *button = qobject_cast<QPushButton*>(sender());
    if (button) {
        QString musicName = button->property("musicName").toString();
        int musicID = MusicID;
        int userID = UserID;  // Set the user ID (replace with actual user ID logic)

        // Create a dialog for entering the comment
        QDialog *commentDialog = new QDialog(this);
        commentDialog->setWindowTitle("Enter Comment");

        QVBoxLayout *dialogLayout = new QVBoxLayout(commentDialog);

        QLabel *label = new QLabel("Enter your comment for " + musicName, commentDialog);
        dialogLayout->addWidget(label);

        QTextEdit *commentTextEdit = new QTextEdit(commentDialog);
        dialogLayout->addWidget(commentTextEdit);

        QHBoxLayout *buttonsLayout = new QHBoxLayout();

        QPushButton *okButton = new QPushButton("OK", commentDialog);
        connect(okButton, &QPushButton::clicked, [this, commentDialog, commentTextEdit, userID, musicID]() {
            QString comment = commentTextEdit->toPlainText();

            QSqlQuery query;
            query.prepare("EXEC AddMusicComment :UserID, :MusicID, :Text");
            query.bindValue(":UserID", userID);
            query.bindValue(":MusicID", musicID);
            query.bindValue(":Text", comment);

            if (query.exec()) {
                if (query.next()) {
                    QString message = query.value(0).toString();
                    QMessageBox::information(this, "Result", message);
                }
            } else {
                QMessageBox::critical(this, "Error", "Failed to execute query: " + query.lastError().text());
            }

            commentDialog->accept();
        });
        buttonsLayout->addWidget(okButton);

        QPushButton *cancelButton = new QPushButton("Cancel", commentDialog);
        connect(cancelButton, &QPushButton::clicked, commentDialog, &QDialog::reject);
        buttonsLayout->addWidget(cancelButton);

        dialogLayout->addLayout(buttonsLayout);

        commentDialog->setLayout(dialogLayout);
        commentDialog->exec();
    }
}


void User::on_likepushButton_clicked()
{

    QSqlQuery query;
    query.prepare("EXEC ToggleMusicLike @user_id = :user_id, @music_id = :music_id");
    query.bindValue(":user_id", UserID);
    query.bindValue(":music_id", MusicID);

    if (!query.exec())
    {
        QString error = query.lastError().text();
        QMessageBox::critical(this, "Error", "Failed to execute query: " + error);
        return;
    }

    // Fetch the result message
    QString message;
    if (query.next())
    {
        message = query.value(0).toString();
    }

    // Display the result message
    QMessageBox::information(this, "Result", message);
}


void User::on_commentsall_clicked()
{
    ui->stackedWidget->setCurrentIndex(12);

    ui->tabWidget_2->setCurrentIndex(0);
    ui->tabWidget_2->setTabText(0, "Music's comment");
    ui->tabWidget_2->setTabText(1, "Album's comment");
    ui->tabWidget_2->setTabText(2, "Playlist's comment");

    if (!db.isOpen()) {
        QMessageBox::critical(this, "Error", "Database is not open.");
        return;
    }

    QSqlQuery query1(db);
    query1.prepare("EXEC GetUserAndFriendsCommentsOnSongs @UserID = :user_id");
    query1.bindValue(":user_id", UserID);

    if (!query1.exec()) {
        QMessageBox::critical(this, "Error", "Failed to execute procedure: " + query1.lastError().text());
        return;
    }

    QString musicContent;
    bool hasResults = false;

    while (query1.next()) {
        hasResults = true;
        QString commenterType = query1.value("CommenterType").toString();
        QString commenterUsername = query1.value("CommenterUsername").toString();
        QString songTitle = query1.value("SongTitle").toString();
        QString commentText = query1.value("CommentText").toString();
        QString currentDateTime = QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss");

        musicContent += QString("Field: %1\nName: %2\nSong: %3\nComment: %4\nDate: %5\n\n")
                .arg(commenterType)
                .arg(commenterUsername)
                .arg(songTitle)
                .arg(commentText)
                .arg(currentDateTime);
    }

    if (!hasResults) {
        musicContent = "No comments found.";
    }

    ui->songscomment->setText(musicContent);
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
    QString albumContent; // This will store the formatted output

    // Assuming you have the UserID stored in a variable named userID
    int userID = UserID; // Replace ... with actual userID

    // Prepare the SQL query to call the stored procedure
    QSqlQuery queryAlbum;
    queryAlbum.prepare("EXEC GetAlbumCommentsForUser @UserID = :userID");
    queryAlbum.bindValue(":userID", userID);

    // Execute the query
    if (!queryAlbum.exec()) {
        qDebug() << "Error executing stored procedure:" << queryAlbum.lastError().text();
        // Handle error (e.g., display error message)
        QMessageBox::critical(this, "Error", "Failed to retrieve album comments.");
        return;
    }

    // Process the results
    while (queryAlbum.next()) {
        QString albumName = queryAlbum.value("AlbumName").toString();
        int commentAlbumID = queryAlbum.value("CommentID").toInt();
        QString commentAlbumText = queryAlbum.value("CommentText").toString();
        QDateTime commentAlbumDate = queryAlbum.value("CommentDate").toDateTime();

        // Format the output as needed
        QString commentAlbumInfo = QString("Album: %1\nComment: %2\nDate: %3\n\n")
                .arg(albumName)
                .arg(commentAlbumText)
                .arg(commentAlbumDate.date().toString("yyyy-MM-dd"));

        // Append to albumContent
        albumContent += commentAlbumInfo;
    }

    // Check if no comments were found
    if (queryAlbum.size() == 0) {
        albumContent = "No comments found for this user.";
    }

    // Set the formatted content to your UI element
    ui->albumscomment->setText(albumContent);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////
    QString playlistContent; // This will store the formatted output

    // Assuming you have the UserID stored in a variable named userID
    //int userID = UserID; // Replace ... with actual userID

    // Prepare the SQL query to call the stored procedure
    QSqlQuery query;
    query.prepare("EXEC GetPlaylistCommentsForUser @UserID = :userID");
    query.bindValue(":userID", userID);

    // Execute the query
    if (!query.exec()) {
        qDebug() << "Error executing stored procedure:" << query.lastError().text();
        // Handle error (e.g., display error message)
        QMessageBox::critical(this, "Error", "Failed to retrieve playlist comments.");
        return;
    }

    // Process the results
    while (query.next()) {
        QString playlistName = query.value("PlaylistName").toString();
        int commentID = query.value("CommentID").toInt();
        QString commentText = query.value("CommentText").toString();
        QDateTime commentDate = query.value("CommentDate").toDateTime();

        // Format the output as needed
        QString commentInfo = QString("Playlist: %1\nComment: %2\nDate: %3\n\n")
                .arg(playlistName)
                .arg(commentText)
                .arg(commentDate.date().toString("yyyy-MM-dd"));

        // Append to playlistContent
        playlistContent += commentInfo;
    }

    // Check if no comments were found
    if (query.size() == 0) {
        playlistContent = "No comments found for this user.";
    }

    // Set the formatted content to your UI element
    ui->playlistcomment->setText(playlistContent);


}



// Helper function to clear the contents of a scroll area
void User::clearScrollArea(QScrollArea *scrollArea)
{
    QWidget *widget = scrollArea->widget();
    if (widget) {
        widget->deleteLater();
    }
}

void User::on_allplaylists_clicked()
{
    ui->stackedWidget->setCurrentIndex(14); // Set current index to show the appropriate page

    // Clear any existing content in scrollArea_18 and scrollArea_19
    clearScrollArea(ui->scrollArea_18);
    clearScrollArea(ui->scrollArea_19);

    // Simulate some data or create default content for scrollArea_18
    QWidget *contentWidget1 = new QWidget(this);
    QVBoxLayout *layout1 = new QVBoxLayout(contentWidget1);
    for (int i = 0; i < 10; ++i) {
        QHBoxLayout *hLayout = new QHBoxLayout();

        QLabel *label = new QLabel(contentWidget1);
        QPixmap pixmap(":/new/prefix1/spotify logo.png");
        pixmap = pixmap.scaled(50, 50, Qt::KeepAspectRatio);
        label->setPixmap(pixmap);
        label->setFixedSize(80, 80);
        hLayout->addWidget(label);

        QPushButton *button = new QPushButton("Playlist " + QString::number(i + 1), contentWidget1);
        button->setFixedSize(150, 50);
        button->setStyleSheet(QPushButtonStyle);
        connect(button, &QPushButton::clicked, this, &User::onShowSongsogPlaylistClicked);
        hLayout->addWidget(button);

        QLabel *createDateLabel = new QLabel("2024-07-12", contentWidget1); // Example creation date
        createDateLabel->setFixedSize(160, 50);
        createDateLabel->setStyleSheet(QLableStyle);
        hLayout->addWidget(createDateLabel);

        QLabel *privacyLabel = new QLabel("Private", contentWidget1); // Example privacy status
        privacyLabel->setFixedSize(100, 50);
        privacyLabel->setStyleSheet(QLableStyle);
        hLayout->addWidget(privacyLabel);

        QPushButton *commentButton = new QPushButton("Comment", contentWidget1);
        commentButton->setProperty("playlistID", i + 1); // Example playlist ID
        connect(commentButton, &QPushButton::clicked, this, &User::onCommentPlaylistButtonClicked);
        commentButton->setStyleSheet(QPushButtonStyle);
        hLayout->addWidget(commentButton);

        QPushButton *favoriteButton = new QPushButton("Add to Favorite List", contentWidget1);
        favoriteButton->setProperty("playlistID", i + 1); // Example playlist ID
        favoriteButton->setFixedSize(210, 50);
        favoriteButton->setStyleSheet(QPushButtonStyle);
        connect(favoriteButton, &QPushButton::clicked, this, &User::onAddToFavoriteListButtonClicked);
        hLayout->addWidget(favoriteButton);

        QPushButton *likeButton = new QPushButton("Like", contentWidget1);
        likeButton->setProperty("playlistID", i + 1); // Example playlist ID
        likeButton->setFixedSize(100, 50);
        likeButton->setStyleSheet(QPushButtonStyle);
        connect(likeButton, &QPushButton::clicked, this, &User::onLikePlaylistButtonClicked);
        hLayout->addWidget(likeButton);

        layout1->addLayout(hLayout);
    }
    ui->scrollArea_18->setWidget(contentWidget1);

    // Simulate some data or create default content for scrollArea_19
    QWidget *contentWidget2 = new QWidget(this);
    QVBoxLayout *layout2 = new QVBoxLayout(contentWidget2);
    for (int i = 0; i < 5; ++i) {
        QHBoxLayout *hLayout = new QHBoxLayout();

        QLabel *label = new QLabel(contentWidget2);
        QPixmap pixmap(":/new/prefix1/spotify logo.png");
        pixmap = pixmap.scaled(50, 50, Qt::KeepAspectRatio);
        label->setPixmap(pixmap);
        label->setFixedSize(80, 80);
        hLayout->addWidget(label);

        QPushButton *button = new QPushButton("Playlist " + QString::number(i + 11), contentWidget2);
        button->setFixedSize(150, 50);
        button->setStyleSheet(QPushButtonStyle);
        connect(button, &QPushButton::clicked, this, &User::onShowSongsogPlaylistClicked);
        hLayout->addWidget(button);

        QLabel *createDateLabel = new QLabel("2024-07-12", contentWidget2); // Example creation date
        createDateLabel->setFixedSize(160, 50);
        createDateLabel->setStyleSheet(QLableStyle);
        hLayout->addWidget(createDateLabel);

        QLabel *privacyLabel = new QLabel("Public", contentWidget2); // Example privacy status
        privacyLabel->setFixedSize(100, 50);
        privacyLabel->setStyleSheet(QLableStyle);
        hLayout->addWidget(privacyLabel);

        QPushButton *commentButton = new QPushButton("Comment", contentWidget2);
        commentButton->setProperty("playlistID", i + 11); // Example playlist ID
        connect(commentButton, &QPushButton::clicked, this, &User::onCommentPlaylistButtonClicked);
        commentButton->setStyleSheet(QPushButtonStyle);
        hLayout->addWidget(commentButton);

        QPushButton *favoriteButton = new QPushButton("Add to Favorite List", contentWidget2);
        favoriteButton->setProperty("playlistID", i + 11); // Example playlist ID
        favoriteButton->setFixedSize(210, 50);
        favoriteButton->setStyleSheet(QPushButtonStyle);
        connect(favoriteButton, &QPushButton::clicked, this, &User::onAddToFavoriteListButtonClicked);
        hLayout->addWidget(favoriteButton);

        QPushButton *likeButton = new QPushButton("Like", contentWidget2);
        likeButton->setProperty("playlistID", i + 11); // Example playlist ID
        likeButton->setFixedSize(200, 50);
        likeButton->setStyleSheet(QPushButtonStyle);
        connect(likeButton, &QPushButton::clicked, this, &User::onLikePlaylistButtonClicked);
        hLayout->addWidget(likeButton);

        layout2->addLayout(hLayout);
    }
    ui->scrollArea_19->setWidget(contentWidget2);
}



void User::on_cancle20_clicked()
{
    ui->stackedWidget->setCurrentIndex(0);
}


void User::on_cancle17_2_clicked()
{

    ui->stackedWidget->setCurrentIndex(0);
}




//---------------------------------------------------------------- Search   ----------------------------------------------------------------------

void User::clearAndSetupScrollArea(QScrollArea *scrollArea) {
    QWidget *contentWidget = new QWidget(this);
    QVBoxLayout *layout = new QVBoxLayout(contentWidget);
    scrollArea->setWidget(contentWidget);
}

void User::executeSearchAndPopulateResults(const QString &queryString, const QString &searchValue, QScrollArea *scrollArea) {
    QSqlQuery query;
    query.prepare(queryString);
    query.bindValue(":search_value", searchValue);

    if (!query.exec()) {
        QMessageBox::critical(this, "Error", "Failed to execute search: " + query.lastError().text());
        return;
    }

    QWidget *contentWidget = scrollArea->widget();
    QVBoxLayout *layout = qobject_cast<QVBoxLayout *>(contentWidget->layout());

    if (!query.next()) {
        QLabel *noResultsLabel = new QLabel("No results found matching the search criteria.", contentWidget);
        layout->addWidget(noResultsLabel);
    } else {
        do {
            QString title = query.value("title").toString();
            QString artist = query.value("artist_name").toString();
            QString genre = query.value("genre").toString();
            QString zone = query.value("zone").toString();
            QString ageCategory = query.value("age_category").toString();

            QLabel *resultLabel = new QLabel("Title: " + title + ", Artist: " + artist + ", Genre: " + genre + ", Zone: " + zone + ", Age Category: " + ageCategory, contentWidget);
            layout->addWidget(resultLabel);
        } while (query.next());
    }
}

void User::on_searchpushButton_clicked() {
    if (ui->searchcomboBox->count() == 0) {
        ui->searchcomboBox->addItem("Title");
        ui->searchcomboBox->addItem("Artist");
        ui->searchcomboBox->addItem("Genre");
        ui->searchcomboBox->addItem("Zone");
        ui->searchcomboBox->addItem("Age Category");
    }

    ui->stackedWidget->setCurrentIndex(16);
    QString searchField = ui->searchcomboBox->currentText();
    QString searchValue = ui->searchlineEdit->text();

    clearScrollArea(ui->albumsearch);
    clearScrollArea(ui->songsearch);

    QString songQueryString = "EXEC SearchSongs ";
    QString albumQueryString = "EXEC SearchAlbums ";

    if (searchField == "Title") {
        songQueryString += "@search_keyword = :search_value";
        albumQueryString += "@search_keyword = :search_value";
    } else if (searchField == "Artist") {
        songQueryString += "@artist_name = :search_value";
        albumQueryString += "@artist_name = :search_value";
    } else if (searchField == "Genre") {
        songQueryString += "@desired_genre = :search_value";
        albumQueryString += "@desired_genre = :search_value";
    } else if (searchField == "Zone") {
        songQueryString += "@desired_zone = :search_value";
        albumQueryString += "@desired_zone = :search_value";
    } else if (searchField == "Age Category") {
        songQueryString += "@desired_age_category = :search_value";
        albumQueryString += "@desired_age_category = :search_value";
    }

    clearAndSetupScrollArea(ui->songsearch);
    executeSearchAndPopulateResults(songQueryString, searchValue, ui->songsearch);

    clearAndSetupScrollArea(ui->albumsearch);
    executeSearchAndPopulateResults(albumQueryString, searchValue, ui->albumsearch);
}

void User::on_searchpushButton_2_clicked() {
    if (ui->searchcomboBox_2->count() == 0) {
        ui->searchcomboBox_2->addItem("Title");
        ui->searchcomboBox_2->addItem("Artist");
        ui->searchcomboBox_2->addItem("Genre");
        ui->searchcomboBox_2->addItem("Zone");
        ui->searchcomboBox_2->addItem("Age Category");
    }

    ui->stackedWidget->setCurrentIndex(16);
    QString searchField = ui->searchcomboBox_2->currentText();
    QString searchValue = ui->searchlineEdit_2->text();

    clearScrollArea(ui->albumsearch);
    clearScrollArea(ui->songsearch);

    QString songQueryString = "EXEC SearchSongs ";
    QString albumQueryString = "EXEC SearchAlbums ";

    if (searchField == "Title") {
        songQueryString += "@search_keyword = :search_value";
        albumQueryString += "@search_keyword = :search_value";
    } else if (searchField == "Artist") {
        songQueryString += "@artist_name = :search_value";
        albumQueryString += "@artist_name = :search_value";
    } else if (searchField == "Genre") {
        songQueryString += "@desired_genre = :search_value";
        albumQueryString += "@desired_genre = :search_value";
    } else if (searchField == "Zone") {
        songQueryString += "@desired_zone = :search_value";
        albumQueryString += "@desired_zone = :search_value";
    } else if (searchField == "Age Category") {
        songQueryString += "@desired_age_category = :search_value";
        albumQueryString += "@desired_age_category = :search_value";
    }

    clearAndSetupScrollArea(ui->songsearch);
    executeSearchAndPopulateResults(songQueryString, searchValue, ui->songsearch);

    clearAndSetupScrollArea(ui->albumsearch);
    executeSearchAndPopulateResults(albumQueryString, searchValue, ui->albumsearch);
}



void User::on_songspushButton_2_clicked()
{
    ui->stackedWidget->setCurrentIndex(3);

    // Clear previous content
    delete ui->scrollArea_3->widget();

    // Check database connection and open if not open
    if (!db.isOpen()) {
        if (!db.open()) {
            QMessageBox::critical(this, "Database Error", "Failed to open the database: " + db.lastError().text());
            return;
        }
    }

    // Prepare the query to call the stored procedure GetAllSongs
    QSqlQuery query;
    query.prepare("EXEC GetAllSongs");

    // Execute the query
    if (!query.exec()) {
        qDebug() << "GetAllSongs stored procedure error:" << query.lastError();
        QMessageBox::critical(this, "Error", "Failed to load songs: " + query.lastError().text());
        return;
    }

    QWidget *contentWidget = new QWidget(this);
    QVBoxLayout *layout = new QVBoxLayout(contentWidget);

    // Loop through the results
    while (query.next()) {
        int songID = query.value(0).toInt();
        QString songTitle = query.value(1).toString();

        QHBoxLayout *hLayout = new QHBoxLayout();

        // Create label for song image
        QLabel *label = new QLabel(contentWidget);
        QPixmap pixmap(":/new/prefix1/spotify logo.png");
        pixmap = pixmap.scaled(150, 150, Qt::KeepAspectRatio);
        label->setPixmap(pixmap);
        label->setFixedSize(200, 200);
        hLayout->addWidget(label);

        // Create button for song name
        QPushButton *songButton = new QPushButton(songTitle, contentWidget);
        songButton->setProperty("ID", songID);
        songButton->setProperty("name", songTitle);
        songButton->setProperty("pic_path", ":/new/prefix1/spotify logo.png");
        songButton->setStyleSheet(QPushButtonStyle);

        // Connect the button directly to the slot with a lambda function
        connect(songButton, &QPushButton::clicked, [this, songID]() {
            onSongButtonClicked2(songID);
        });

        songButton->setFixedSize(400, 100);

        QSizePolicy policy(QSizePolicy::Fixed, QSizePolicy::Fixed);
        policy.setHeightForWidth(true);
        songButton->setSizePolicy(policy);

        hLayout->addWidget(songButton);
        layout->addLayout(hLayout);
    }

    ui->scrollArea_3->setWidget(contentWidget);
}




void User::on_buypremiumpushButton_2_clicked()
{
    // Assuming db is your QSqlDatabase object, and you have established a connection
    QSqlQuery query(db);

    query.prepare("EXEC UpgradeToPremium @user_id=:userID");
    query.bindValue(":userID", UserID); // Replace with actual user ID

    if (!query.exec()) {
        QMessageBox errorBox;
        errorBox.setStyleSheet(QMessageBoxStyle);
        errorBox.setIcon(QMessageBox::Critical);
        errorBox.setWindowTitle("Error");
        errorBox.setText("Failed to upgrade to premium:");
        errorBox.exec();
        return;
    }

    if (query.next()) {
        QString message = query.value("Message").toString(); // Retrieve the output message

        if (message.contains("successfully")) {
            QMessageBox successBox;
            successBox.setStyleSheet(QMessageBoxStyle);
            successBox.setIcon(QMessageBox::Information);
            successBox.setWindowTitle("Success");
            successBox.setText(message);
            successBox.exec();
            ui->addmusicpushButton->setVisible(false);
            ui->stackedWidget->setCurrentIndex(0);
        } else {
            QMessageBox errorBox;
            errorBox.setStyleSheet(QMessageBoxStyle);
            errorBox.setIcon(QMessageBox::Critical);
            errorBox.setWindowTitle("Error");
            errorBox.setText(message); // Display the error message from the procedure
            errorBox.exec();
        }
    } else {
        QMessageBox errorBox;
        errorBox.setStyleSheet(QMessageBoxStyle);
        errorBox.setIcon(QMessageBox::Critical);
        errorBox.setWindowTitle("Error");
        errorBox.setText("Unknown error occurred.");
        errorBox.exec();
    }
}

void User::on_chargepushButton_2_clicked()
{
    QString amountText = ui->lineEdit_2->text().trimmed();

    if (amountText.isEmpty()) {
        QMessageBox::warning(this, "Error", "Please enter an amount.");
        return;
    }

    bool ok;
    double amount = amountText.toDouble(&ok);

    if (!ok) {
        QMessageBox::warning(this, "Error", "Invalid amount format.");
        return;
    }

    // Assuming db is your QSqlDatabase object, and you have established a connection
    QSqlQuery query(db);

    query.prepare("EXEC RechargeWallet @UserID=:userID, @Amount=:amount");
    query.bindValue(":userID", UserID); // Replace with actual user ID
    query.bindValue(":amount", amount);

    if (!query.exec()) {
        QMessageBox::critical(this, "Error", "Failed to recharge wallet: " + query.lastError().text());
        return;
    }

    if (query.next()) {
        QString message = query.value(0).toString(); // "Recharge successful!" or "No wallet found..."
        QMessageBox::information(this, "Info", message);

        if (query.record().indexOf("UpdatedBalance") != -1) {
            double updatedBalance = query.value("UpdatedBalance").toDouble();
            // Assuming updateUserBalance is a method in your User class or related backend logic
            updateUserBalance(updatedBalance);
        }
    }
}




void User::on_logout_2_clicked()
{
    refreshmainpage();
    sign *h = new sign(); // Replace PremiumMenu with your actual premium menu class
    h->show();
    this->close();



}


void User::on_chat_clicked()
{
    ui->stackedWidget->setCurrentIndex(17);
}


void User::on_cancle5_2_clicked()
{
    ui->stackedWidget->setCurrentIndex(0);
}


void User::on_cancle5_3_clicked()
{

}