mainwindow.cpp

#include "mainwindow.h"
#include <QMessageBox>

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent), remainingFlag(MINE_COUNT), elapsedSeconds(0),
    gameOver(false), firstClick(true)
{
    initializeUI();
}

MainWindow::~MainWindow() {}

void MainWindow::initializeUI() {
    centralWidget = new QWidget(this);
    setCentralWidget(centralWidget);

    // Create layout
    QVBoxLayout* mainLayout = new QVBoxLayout(centralWidget);

    // Create info panel
    QHBoxLayout* infoLayout = new QHBoxLayout();
    flagCountLabel = new QLabel(QString("Flag: %1").arg(remainingFlag));
    timerLabel = new QLabel("Time: 0");
    newGameButton = new QPushButton("New Game");

    infoLayout->addWidget(flagCountLabel);
    infoLayout->addWidget(newGameButton);
    infoLayout->addWidget(timerLabel);

    mainLayout->addLayout(infoLayout);

    // Create grid
    gridLayout = new QGridLayout();
    gridLayout->setSpacing(1);

    buttons.resize(GRID_SIZE);
    for(int i = 0; i < GRID_SIZE; ++i) {
        buttons[i].resize(GRID_SIZE);
        for(int j = 0; j < GRID_SIZE; ++j) {
            MineButton* button = new MineButton(i, j);
            button->setFixedSize(30, 30);
            button->setContextMenuPolicy(Qt::CustomContextMenu);

            connect(button, &QPushButton::clicked, this, &MainWindow::handleClick);
            connect(button, &QPushButton::customContextMenuRequested, this, &MainWindow::handleRightClick);

            buttons[i][j] = button;
            gridLayout->addWidget(button, i, j);
        }
    }

    mainLayout->addLayout(gridLayout);

    // Set up timer
    timer = new QTimer(this);
    connect(timer, &QTimer::timeout, this, &MainWindow::updateTimer);
    connect(newGameButton, &QPushButton::clicked, this, &MainWindow::newGame);
}

// Place Mines expect on the player first click
void MainWindow::placeMines(int rowFirstClick, int colFirstClick) {
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<> dis(0, GRID_SIZE - 1);

    int placedMines = 0;
    while(placedMines < MINE_COUNT) {
        int row = dis(gen);
        int col = dis(gen);

        if (!(row == rowFirstClick && col == colFirstClick)){
            MineButton* button = buttons[row][col];
            if(!button->hasMine) {
                button->hasMine = true;
                placedMines++;
            }
        }
    }

    calculateAdjacentMines();
}

void MainWindow::calculateAdjacentMines() {
    for(int i = 0; i < GRID_SIZE; ++i) {
        for(int j = 0; j < GRID_SIZE; ++j) {
            if(!buttons[i][j]->hasMine) {
                int count = 0;
                auto adjacentCells = getAdjacentCells(i, j);

                for(const auto& cell : adjacentCells) {
                    if(buttons[cell.first][cell.second]->hasMine) {
                        count++;
                    }
                }

                buttons[i][j]->adjacentMines = count;
            }
        }
    }
}

QVector<QPair<int, int>> MainWindow::getAdjacentCells(int row, int col) {
    QVector<QPair<int, int>> adjacent;
    for(int i = -1; i <= 1; ++i) {
        for(int j = -1; j <= 1; ++j) {
            if(i == 0 && j == 0) continue;

            int newRow = row + i;
            int newCol = col + j;

            if(newRow >= 0 && newRow < GRID_SIZE &&
                newCol >= 0 && newCol < GRID_SIZE) {
                adjacent.push_back({newRow, newCol});
            }
        }
    }
    return adjacent;
}

void MainWindow::handleClick() {
    if(gameOver) return;

    MineButton* button = qobject_cast<MineButton*>(sender());
    if(!button || button->isMarked) return;

    if(firstClick) {
        firstClick = false;
        timer->start(1000);
        placeMines(button->row, button->col);
    }

    revealCell(button->row, button->col);

    if(button->hasMine) {
        revealAllMines();
        timer->stop();
        gameOver = true;
        QMessageBox::information(this, "Game Over", "You hit a mine!");
    } else if(checkWin()) {
        timer->stop();
        gameOver = true;
        QMessageBox::information(this, "Congratulations", "You won!");
    }
}

void MainWindow::handleRightClick() {
    if(gameOver) return;

    MineButton* button = qobject_cast<MineButton*>(sender());
    if(!button || button->isRevealed) return;

    if(button->isMarked){
        button->isMarked = false;
        button->setText("");
        remainingFlag++;
    }
    else{
        if(remainingFlag>0){
            button->isMarked = true;
            button->setText("🚩");
            remainingFlag--;
        }
    }

    flagCountLabel->setText(QString("Flag: %1").arg(remainingFlag));
}

void MainWindow::revealCell(int row, int col) {
    MineButton* button = buttons[row][col];
    if(button->isRevealed || button->isMarked) return;

    button->isRevealed = true;

    if(button->hasMine) {
        button->setText("💣");
        button->setStyleSheet("background-color: red;");
    } else if(button->adjacentMines > 0) {
        button->setText(QString::number(button->adjacentMines));

        // Set different colors for different numbers
        QVector<QString> colors = {"blue", "green", "red", "purple", "maroon", "turquoise", "black", "gray"};
        button->setStyleSheet(QString("color: %1;").arg(colors[button->adjacentMines - 1]));
    } else {
        // Reveal adjacent cells recursively
        const auto adjacentCells = getAdjacentCells(row, col);
        for(const auto& cell : adjacentCells) {
            revealCell(cell.first, cell.second);
        }
        button->setStyleSheet("background-color: lightgray;");
    }
}

void MainWindow::revealAllMines() {
    for(int i = 0; i < GRID_SIZE; ++i) {
        for(int j = 0; j < GRID_SIZE; ++j) {
            MineButton* button = buttons[i][j];
            if(button->hasMine) {
                button->setText("💣");
                button->setStyleSheet("background-color: red;");
            }
        }
    }
}

bool MainWindow::checkWin() {
    for(int i = 0; i < GRID_SIZE; ++i) {
        for(int j = 0; j < GRID_SIZE; ++j) {
            MineButton* button = buttons[i][j];
            if(!button->hasMine && !button->isRevealed) {
                return false;
            }
        }
    }
    return true;
}

void MainWindow::updateTimer() {
    elapsedSeconds++;
    timerLabel->setText(QString("Time: %1").arg(elapsedSeconds));
}

void MainWindow::newGame() {
    for (int i = 0; i < GRID_SIZE; ++i) {
        for (int j = 0; j < GRID_SIZE; ++j) {
            if (buttons[i][j]) {
                buttons[i][j]->deleteLater();
            }
        }
    }
    buttons.clear();


    remainingFlag = MINE_COUNT;
    elapsedSeconds = 0;
    gameOver = false;
    firstClick = true;

    flagCountLabel->setText(QString("Flag: %1").arg(remainingFlag));
    timerLabel->setText("Time: 0");
    timer->stop();

    buttons.resize(GRID_SIZE);
    for (int i = 0; i < GRID_SIZE; ++i) {
        buttons[i].resize(GRID_SIZE);
        for (int j = 0; j < GRID_SIZE; ++j) {
            MineButton* button = new MineButton(i, j);
            button->setFixedSize(30, 30);
            button->setContextMenuPolicy(Qt::CustomContextMenu);

            connect(button, &QPushButton::clicked, this, &MainWindow::handleClick);
            connect(button, &QPushButton::customContextMenuRequested, this, &MainWindow::handleRightClick);

            buttons[i][j] = button;
            gridLayout->addWidget(button, i, j);
        }
    }
}