/*----------------------------------------------------------
 *				HTBLA-Leonding / Class: 2IHIF
 * ---------------------------------------------------------
 * Exercise Number: B1
 * Title:			Mine Sweeper Game implementation
 * Author:			Marc Tismonar
 * ----------------------------------------------------------
 * Description:
 * Implementation of ms_game.h.
 * ----------------------------------------------------------
 */

#include <stdlib.h>
#include "ms_game.h"
#include "ms_board.h"
#include "ms_cell.h"
#include "ms_ui_utils.h"

/** Encapsulate a cell and its board coordinates */
struct MsCellCoord {
    MsCell cell;
    ColAddr col;
    RowAddr row;
};

/** The only instance of cell data */
static struct MsCellCoord cell_coords[MAX_BOARD_SIZE * MAX_BOARD_SIZE] = {0};

/** The struct holding the data of the game */
struct MsGameData {
    MsBoard board;
    GameState state;
};

/** The instance of the game */
static MsGame the_game = 0;

/**
 * Starts a new game using the given mode. If a mode with a
 * predefined configuration is used, this function shall actually start
 * the game with that configuration using function `msg_start_game`.
 * Otherwise, the user shall be prompted for required attributes 
 * (board size, mines) and the game is started afterwards.
 * 
 * @param mode The configuration mode of the game to start.
 * @return The game if if could be started with a predefined configuration,
 * or 0 if it was not started because a custom configuration is required.
 */
MsGame msg_start_configured_game(GameMode mode) {
    if (the_game != 0) {
        the_game->state = INVALID;
    }

    Count cols = 0;
    Count rows = 0;
    Count mines = 0;

    switch (mode) {
        case BEGINNER:
            cols = 9;
            rows = 9;
            mines = 10;
            break;
        case ADVANCED:
            cols = 16;
            rows = 16;
            mines = 40;
            break;
        case EXPERT:
            cols = 30;
            rows = 16;
            mines = 99;
            break;
        case CUSTOM:
        default:
            return 0;
    }

    return msg_start_game(cols, rows, mines);
}

/**
 * Starts a new game, regardless of the state of the current game.
 * Therefore, completed games or games in progress are aborted 
 * and a new game is 'restarted'.
 * 
 * Note: Mines are distributed when the first cell is uncovered
 * to ensure to uncover an empty cell.
 * 
 * @param column_count The number of columns to use on the game board.
 * @param row_count The number of rows to use on the game board.
 * @param mine_count The number of mines distributed on the board.
 *                    It must be greater than 0;
 * @return The started game or 0 in case errors.
 */
MsGame msg_start_game(Count column_count, Count row_count, Count mine_count) {
    if (the_game != 0) {
        the_game->state = INVALID;
    }

    if (column_count == 0 || row_count == 0 || mine_count == 0 || column_count * row_count < mine_count + 9) {
        return 0;
    }

    the_game = (MsGame)calloc(1, sizeof(struct MsGameData));
    the_game->board = msb_get_board();
    msb_init_board(the_game->board, column_count, row_count);
    the_game->state = IN_PROGRESS;

    for (CellIdx row = 0; row < row_count; row++) {
        for (CellIdx col = 0; col < column_count; col++) {
            cell_coords[row * column_count + col].cell = msb_get_cell(the_game->board, col, row);
            cell_coords[row * column_count + col].col = msu_idx_to_col_address(col);
            cell_coords[row * column_count + col].row = msu_idx_to_row_address(row);
        }
    }

    return the_game;
}

/**
 * Determines whether or not the given game is valid.
 * A game is NOT valid, if:
 *      + it is 0 
 *      + or if it has an invalid board
 *      + or if it has no mines
 *      + or if it has less than 10 cells
 *      + or if it has more mines than cells - 9.
 * 
 * @param game The game instance in focus.
 * @return True if the given game is valid, false otherwise.
 */
bool msg_is_valid(MsGame game) {
    if (game == 0 || !msb_is_valid(game->board)) {
        return false;
    }

    Count cols = msb_get_column_count(game->board);
    Count rows = msb_get_row_count(game->board);
    Count mines = 0;

    bool any_uncovered = false;
    for (CellIdx row = 0; row < rows && !any_uncovered; row++) {
        for (CellIdx col = 0; col < cols && !any_uncovered; col++) {
            MsCell cell = msb_get_cell(game->board, col, row);
            if (!msc_is_covered(cell)) {
                any_uncovered = true;
            }
        }
    }

    if (any_uncovered) {
        Count mines = 0;
        for (CellIdx row = 0; row < rows; row++) {
            for (CellIdx col = 0; col < cols; col++) {
                if (msc_has_mine(msb_get_cell(game->board, col, row))) {
                    mines++;
                }
            }
        }
        return cols * rows >= 10 && mines > 0 && mines < cols * rows - 9;
    }

    return cols * rows >= 10;
}

/**
 * Selects the addressed cell without performing any action on that cell. Only 
 * covered cells can be selected. The function clears any previous selection
 * and selects the addressed cell. Therefore invalid addresses or already uncovered cells
 * has only the effect of clearing a previous selection.
 * 
 * To avoid uncovering unwanted cells due to wrong user inputs, the cell to uncover
 * is selected in the first step. Only the selected cell can be uncovered.
 * 
 * @param game The game instance in focus.
 * @param column The column of the cell to select in the format used on the UI (e.g. 'A', 'B').
 * @param row The row of the cell to select in the format used on the UI (e.g. 1, 2).
 * @return True if the addressed cell is selected, false otherwise.
 */
bool msg_select_cell(MsGame game, ColAddr column, RowAddr row) {
    if (!msg_is_valid(game)) {
        return false;
    }

    Count cols = msb_get_column_count(game->board);
    Count rows = msb_get_row_count(game->board);
    CellIdx col_idx = msu_col_address_to_index(column);
    CellIdx row_idx = msu_row_address_to_index(row);

    if (col_idx >= cols || row_idx >= rows) {
        return false;
    }

    MsCell cell = msb_get_cell(game->board, col_idx, row_idx);
    if (!msc_is_covered(cell)) {
        return false;
    }

    for (CellIdx r = 0; r < rows; r++) {
        for (CellIdx c = 0; c < cols; c++) {
            cell_coords[r * cols + c].cell = 0;
            cell_coords[r * cols + c].col = 0;
            cell_coords[r * cols + c].row = 0;
        }
    }

    cell_coords[row_idx * cols + col_idx].cell = cell;
    cell_coords[row_idx * cols + col_idx].col = column;  
    cell_coords[row_idx * cols + col_idx].row = row;


    return true;
}

/** 
 * Provides the currently selected cell.
 * 
 * @return The currently selected cell or 0,
 * if no cell is selected.
 */
MsCell msg_get_selected_cell(MsGame game) {
    if (!msg_is_valid(game)) {
        return 0;
    }

    Count cols = msb_get_column_count(game->board);
    Count rows = msb_get_row_count(game->board);

    for (CellIdx r = 0; r < rows; r++) {
        for (CellIdx c = 0; c < cols; c++) {
            if (cell_coords[r * cols + c].cell != 0) {
                return cell_coords[r * cols + c].cell;
            }
        }
    }

    return 0;
}

/**
 * Uncovers the currently selected cell.
 * To avoid uncovering unwanted cells due to wrong user inputs, the cell to uncover
 * must be selected in the first step via function ´msg_select_cell´. 
 * 
 * Only the selected cell can be uncovered, otherwise the invocation is ignored.
 * No cell is selected afterwards.
 * 
 * Mines are randomly distributed on the board when the first cell of a game is uncovered.
 * Mines shall be distributed in a way that keeps the first uncovered cell empty.
 * Depending on the size of the board and the number of mines, the randomized mine distribution
 * may take long to find a proper cell for all mines. Therefore mine distribution shall be
 * aborted after 10 X mine-count trials. The number of mines on the board need to be updated
 * accordingly, if not all mines could be dropped. 
 * 
 * @param game The game instance in focus.
 */
void msg_uncover_selected_cell(MsGame game) {
    if (!msg_is_valid(game)) {
        return;
    }

    MsCell cell = msg_get_selected_cell(game);
    if (cell == 0) {
        return;
    }

    if (!msc_uncover(cell)) {
        return;
    }

    Count cols = msb_get_column_count(game->board);
    Count rows = msb_get_row_count(game->board);
    Count mines = 0;

    for (CellIdx r = 0; r < rows; r++) {
        for (CellIdx c = 0; c < cols; c++) {
            if (msc_has_mine(msb_get_cell(game->board, c, r))) {
                mines++;
            }
        }
    }

    if (mines == 0) {
        return;
    }

    for (CellIdx r = 0; r < rows; r++) {
        for (CellIdx c = 0; c < cols; c++) {
            MsCell current = msb_get_cell(game->board, c, r);
            if (msc_has_mine(current)) {
                msc_drop_mine(current);
            }
        }
    }
}

/**
 * Sets the marker on the addressed cell. To clear the marker, the marker ´NONE´ is used.
 * The cell to mark must be selected in the first step via function ´msg_select_cell´. 
 * Only the selected cell can be marked, otherwise the invocation is ignored.
 * No cell is selected afterwards.
 * 
 * Note: The number of set mine-detected markers must NOT be larger than the number
 * of mines on the board.
 * 
 * @param game The game instance in focus.
 * @param marker The marker to apply.
 */
void msg_mark_selected_cell(MsGame game, CellMarker marker) {
    if (!msg_is_valid(game)) {
        return;
    }

    MsCell cell = msg_get_selected_cell(game);
    if (cell == 0) {
        return;
    }

    if (marker == MINE_DETECTED) {
        Count mines = msg_get_mines_left_count(game);
        if (mines == 0) {
            return;
        }
    }

    msc_set_marker(cell, marker);
}

/**
 * Determines the state of the current game.
 * 
 * @param game The game instance in focus.
 * @return The state of the current game.
 */
GameState msg_get_state(MsGame game) {
    if (!msg_is_valid(game)) {
        return INVALID;
    }

    Count cols = msb_get_column_count(game->board);
    Count rows = msb_get_row_count(game->board);
    Count mines = 0;
    Count uncovered = 0;

    for (CellIdx r = 0; r < rows; r++) {
        for (CellIdx c = 0; c < cols; c++) {
            MsCell cell = msb_get_cell(game->board, c, r);
            if (msc_has_mine(cell) && msc_get_marker(cell) == MINE_DETECTED) {
                mines++;
            }
            if (!msc_is_covered(cell)) {
                uncovered++;
            }
        }
    }

    if (uncovered == cols * rows) {
        return SOLVED;
    }

    if (mines > 0) {
        return FAILED;
    }

    return IN_PROGRESS;
}

/**
 * Provides the number of mines that are detected. 
 * This is the difference of total number of mines the board carries
 * minus the number of cells being marked as 'detected'.
 * Cells marked as 'suspected' does not contribute to this value.
 * 
 * @param game The game instance in focus.
 * @return The number of undetected mines
 *         or 0, if the game is not valid.
 */
Count msg_get_mines_left_count(MsGame game) {
    if (!msg_is_valid(game)) {
        return 0;
    }

    Count cols = msb_get_column_count(game->board);
    Count rows = msb_get_row_count(game->board);
    Count mines = 0;

    for (CellIdx r = 0; r < rows; r++) {
        for (CellIdx c = 0; c < cols; c++) {
            MsCell cell = msb_get_cell(game->board, c, r);
            if (msc_has_mine(cell) && msc_get_marker(cell) == MINE_DETECTED) {
                mines++;
            }
        }
    }

    return mines;
}

/**
 * Provides the number of cells that are suspected carrying mines.
 * 
 * @param game The game instance in focus.
 * @return The number of suspected mines
 *         or 0, if the game is not valid.
 */
Count msg_get_mines_suspected_count(MsGame game) {
    if (!msg_is_valid(game)) {
        return 0;
    }

    Count cols = msb_get_column_count(game->board);
    Count rows = msb_get_row_count(game->board);
    Count mines = 0;

    for (CellIdx r = 0; r < rows; r++) {
        for (CellIdx c = 0; c < cols; c++) {
            MsCell cell = msb_get_cell(game->board, c, r);
            if (msc_has_mine(cell) && msc_get_marker(cell) == MINE_SUSPECTED) {
                mines++;
            }
        }
    }

    return mines;
}

/**
 * Provides the number of times a cell was actively uncovered by the user.
 * Note: This is not (necessarily) equal to the number of uncovered cells,
 * because uncovering empty cells uncovers more than one cell. Such an
 * activity is counted as 'one action' only.
 * 
 * @param game The game instance in focus.
 * @return The number of times the used uncovered a cell
 *         or 0, if the game is not valid.
 */
Count msg_get_uncover_action_count(MsGame game) {
    if (!msg_is_valid(game)) {
        return 0;
    }

    Count cols = msb_get_column_count(game->board);
    Count rows = msb_get_row_count(game->board);
    Count actions = 0;

    for (CellIdx r = 0; r < rows; r++) {
        for (CellIdx c = 0; c < cols; c++) {
            MsCell cell = msb_get_cell(game->board, c, r);
            if (!msc_is_covered(cell)) {
                actions++;
            }
        }
    }

    return actions;
}

/**
 * Provides access to the underlying game board. This function is intended
 * for being used by game visualizer but should not be needed by the game 
 * application.
 * 
 * @param game The game instance in focus.
 * @return The board used by the game instance or 0, if the game is invalid.
 */
MsBoard msg_get_board(MsGame game) {
    return msg_is_valid(game) ? game->board : 0;
}