#include "Game2048.hpp" //This allows the main.cpp file to use the game 2048 and it methods.

int main() { //This main function is the entry point of the program and is complied to run the game.
    Game2048 game; //This creates an instance of the game2048 class named game, the constructor of the class is called here to initialize the game.
    game.start(); //This calls the start method, this method is responsible for starting the game which includes: initializing the game board, generating the intitial cells and entering the game loop where the game is ready to be played and moves inputed by the user.
    return 0; //Finally the return 0 function indicates the program has be executed succesfully.
}

board = std::vector<std::vector<int>>(4, std::vector<int>(4, 0));** //In control of initializing the board: this piece of code creates a 4x4 grid and places two nuumbers randomly at the start of the game.

**srand(time(0));** //In control seeding the random number generator: this creates the random numbers that pops up at the start of the game and after the user carrys out a move.

generateNewTile(); //In control of generating cells at the start of the game: this is required in this main function to generate new cells for the start of the game and without this line of code the grid would just be full of 0 and would not be able to work.

void Game2048::start(){}
    while (!isGameOver()){}

printBoard(); //this command is used to visually display the board on the command line.

char move; //This declares the vaiable move which is used for user input.
       std::cin >> move; //this is when the user inputs a command of one of the key written in the code below.
       switch (move) { }//switch command is used to execute the block of code below based on the value of a variable.

switch (move) {
            case 'j' : moveUp(); break;
            case 'n' : moveDown(); break;
            case 'b' : moveLeft(); break;
            case 'm' : moveRight(); break;
            default: continue; //The default command is if the user fails to enter one of the letter above.
        }

generateNewTile(); //This code does the same as above but is control of generating new cells after the user input has been processed.

std::cout << "Game Over!" << std::endl;** //when the statement at boollean at the start of the main loop is false the game will end and print game over.

void Game2048::printBoard() { //This function displays the current state of the game board.
    for (const auto& row : board) { //Scans through each row of the board.
        for (const auto& cell : row){ //Scans through each individual cell.
            std::cout << cell << "\t"; //Checks value of the cell.

        }
        std::cout << std::endl; //After all the cells of a row are printed this command moves the cursor to a new line to seperate the rows.
    }
}

bool Game2048::move(left or right)() { //This command is in control of the logic of shifting the all the cells to the left or right on the game board.
    bool moved = false; //This command checks if any of the cells were shifted or merged, decides wether to display an updated board or generate a new cell and confirm if a valid move was made or prompt the user to try again.
    for (auto& row : board) { //This is a for loop to iterate through the rows of the board and apply the merge funtion. for the right function it will also apply the reverse function.
        std::reverse(row.begin(), row.end()); //This line of code is so that the same code for the left function can be used by just shifts the cells the opposite way this makes it simple and easier to understand.
        merge (row); //This merges the cells in the rows when the move left or right command is used.
        for (int i = 0; i < 4; ++i){ //Scans through each element in the row. 
            if (row[i] == 0) { //If the current cell is a zero.
                for (int j = i + 1; j < 4; ++j) { //Look for the next non-zero cell.
                    if (row[j] != 0) { //Found a non-zero cell it can carry out the commands in the if loop if not carries on looking for non-zero cells
                        row[i] = row[j]; //Moves it to the current empty spot
                        row[j] = 0; //Set the orignal spot to zero 
                        moved = true; //Track that a move has occured
                        break; //Stop checking for zero cells
                    }
                }
            }
        }
        std::reverse(row.begin(), row.end()); //This line of code is for the move right function only 
    }
    return moved;

}

bool Game2048::move(up or down)() { //This command is in control of the logic of shifting the all the cells up or down on the game board.
    bool moved = false; //This command checks if any of the cells were shifted or merged, decides wether to display an updated board or generate a new cell and confirm if a valid move was made or prompt the user to try again.
    for (int col = 0; col < 4; ++col) { 
        std::vector<int> column(4);//This code is extracting colums from the game board and storing them into the **std::vector<int> column** this is need when merging or shifting cells up and down.
        for (int row = 0; row < 4; ++row) {
            column[row] = board[row][col]; //This code is continuing the extracting process of the game board, this is each element from a specific column (col) into the matching row index of the column vector.
        }
        std::reverse(column.begin(), column.end()); //Is used to reverse the upwards funtion so that the move down function works. this line of code is only used in the move down function 
        merge(column); //This merges the cells in the columns when the move up or down function is used 
        for (int i = 0; i < 4; ++i) { //Scans through the column
            if(column[i] == 0) { //Checks uf the current cell is zero
                for (int j = i + 1; j < 4; ++j) { //Looks below for a non-zero cells
                    if (column[j] != 0) { //When a non-zero cells is found it can carry out the commands in the if loop if not it carrys on looking for non-zero cells
                        column[i] = column[j]; //Move it to the current empty cells
                        column[j] = 0; //Clear the orignal cells
                        moved = true; //Track that move occured
                        break; //Stop searching further for the zero cells
                    }
                }

            }
        }
        std::reverse(column.begin(), column.end()); //Is used to reverse the upwards funtion so that the move down function works. this line of code is only used in the move down function
        for (int row  = 0; row < 4; ++row) {
            board[row][col] = column[row];
        }
    }
    return moved;
}

bool Game2048::isGameOver() { // checks for empty cells
    for (const auto& row : board) {
        for (const auto& cell : row) { 
            if(cell == 0) return false; //The game can carry on if there is an empty cell
        }
    }
    return true; //If returned true there arent an empty cells so it ends the game
}

void Game2048::generateNewTile() {
    int row, col; // declares row and column variable
    do {
        row = rand() % 4; //Generates a random number between 0 and 3 for the row.
        col = rand() % 4; //Genrates a random number between 0 and 3 for the column.
    } 
    while (board[row][col] != 0); //Finds random empty cell and it must be empty.
    board[row][col] = (rand() % 2 + 1) * 2; //This randomly assigns either a 2 or a 4 to the chosen empty cell.
}

void Game2048::merge(std::vector<int>& row) {
    for (int i = 0; i < 3; ++i) { //Scans through the row elements stopping at the second to last element and comparing row[i] with row [i+1].
        if (row[i] != 0 && row[i] == row[i + 1]) { //These conditions are to ensure only non-zero cells are processed and checks the current row matches the adjacent one.
            row[i] *= 2; //This doubles the value of the current cell when merged.
            row[i + 1] = 0; //Sets the adjacent cell to zero after merging.
            ++i; //Makes sure no double mergers are happening within a single pass by advancing the loop index to skip the next cell.
        }
    }
}

#ifndef GAME2048_HPP 
#define GAME2048_HPP // header guards - defines GAME2048_HPP to reduce inclusion errors.


#include <vector> // inludes <vector> header which enables use of std::vector.


class Game2048 { // defines the GAME2048 class with public and private members.


public: //Public methods provide the function to: start the game, print the board, move cells in different directions, check if the game is over.
    Game2048();
    void start();
    void printBoard();
    bool moveLeft();
    bool moveRight();
    bool moveUp();
    bool moveDown();
    bool isGameOver();
private: //Private methods provide funtion to: generate new tiles and merge cells during moves.
    std::vector<std::vector<int>> board;
    void generateNewTile();
    void merge(std::vector<int>& row);
};
#endif // GAME2048_HPP //The final line ends the header guard that was started at the beginning of the file.