#include "stdafx.h"
#include <iostream>
#include <ctime>
#include <iomanip>


struct square
{
    int value; //every square has a value from 0 to 8 so mines can be 9
    bool is_covered; //every square is covered or uncovered
};

square board[10][10];

void clear_board(int &min_column_or_row_numb, int &max_column_or_row_numb)
{

    for (int i = min_column_or_row_numb; i <= max_column_or_row_numb; i++)
    {
            for (int j = min_column_or_row_numb; j <= max_column_or_row_numb; j++)
            {
                board[i][j].value = 0;
                board[i][j].is_covered = false;
            }
    }
}

void place_bombs(int *bombs, int &min_column_or_row_numb, int &max_column_or_row_numb) //places as many bombs as user wants randomly
{
    using namespace std;

    int max_bombs_number = 99;
    int min_bombs_number = 0;

    if (*bombs < min_bombs_number || *bombs > max_bombs_number)
    {
        cout << "Podales zla ilosc bomb zagraj ponownie" << endl;
        return;
    }

    clear_board(min_column_or_row_numb, max_column_or_row_numb);//fills the board with zeros
    srand(time(NULL));
    int bomb_count = 0;
    while (bomb_count < *bombs) //to eliminate the repeating values
    for (int i = 0; i < *bombs; i++)
    {
            int a = rand() % (max_column_or_row_numb+1);
            int b = rand() % (max_column_or_row_numb + 1);

            if (board[a][b].value == 9) continue; //if the bomb already was here - skip the loop
            else
            {
                bomb_count++;
                board[a][b].value = 9;

                int record_on_the_left = -1;
                int record_on_the_right = 1;
                int mine_value = 9;

                for (int j = record_on_the_left; j <= record_on_the_right; j++)
                    for (int k = record_on_the_left; k <= record_on_the_right; k++)
                    {
                        if ((a + k) >= min_column_or_row_numb && (b + j) >= min_column_or_row_numb)  //not to exceed the board
                            if ((a + k) <= max_column_or_row_numb && (b + j) <= max_column_or_row_numb)  //nnot to exceed the board

                                if (board[a + k][b + j].value != mine_value)  //it cant be a mine in this square
                                    board[a + k][b + j].value += 1;//increase the walue of the square
                    }
            }
    }
    }

void show_board(int &min_column_or_row_numb, int &max_column_or_row_numb)
{
    using namespace std;
    int mine_value = 9;

    for (int i = min_column_or_row_numb; i <= max_column_or_row_numb; i++) //displays board filled wth zeros and bombs
    {
        if (i == 0)   //shows column number
        {
            cout << "    ";
            for (int k = 0; k < 10; k++)
                cout << k + 1;
            cout << endl;
            cout << "-----------------" << endl;

        }
        cout << setw(2) << i + 1 << "| ";
        for (int j = min_column_or_row_numb; j <= max_column_or_row_numb; j++)
        {
            if (board[i][j].value == mine_value) cout << "*";
            if (board[i][j].value == 0) cout << " ";
            if (board[i][j].value != 0 && board[i][j].value != mine_value)
                cout << board[i][j].value;
        }
        cout << endl;
    }
}

void show_part_of_board(int &min_column_or_row_numb, int &max_column_or_row_numb)
{
    using namespace std;
    int mine_value = 9;

    for (int i = min_column_or_row_numb; i <= max_column_or_row_numb; i++)
    {
        if (i == 0)   //shows column number
        {
            cout << "    ";
            for (int k = min_column_or_row_numb; k <= max_column_or_row_numb;k++)
                cout << k+1;
            cout << endl;
            cout << "-----------------" << endl;

        }
        cout << setw(2)<< i + 1 << "| ";

        for (int j = min_column_or_row_numb; j <= max_column_or_row_numb; j++)
        {

            if (board[i][j].is_covered == true) // the square is uncovered
            {
                if (board[i][j].value == 0) //if value is  0 show blank space
                    cout << " ";
                else
                    cout << board[i][j].value; //show the value from 1-8
            }
            if (board[i][j].is_covered == false) //square is covered
                cout << "#"; //show #
        }
        cout << endl;
    }
}

void show_squares(int x, int y, int &min_column_or_row_numb, int &max_column_or_row_numb)
{
    using namespace std;

    if (x<min_column_or_row_numb || x>max_column_or_row_numb) return; // out of range
    if (y<min_column_or_row_numb || y>max_column_or_row_numb) return; // out of range
    if (board[x][y].is_covered == true) return; // it is already discovered

    if (board[x][y].value != 9 && board[x][y].is_covered == false)
        board[x][y].is_covered = true; //show the square

    if (board[x][y].value != 0) return; // u need to uncover the whole sequence of zeros
                                           //u need to show contour of the zeros

    for (int j = -1; j < 2; j++)
        for (int k = -1; k < 2; k++)
        {
            show_squares(x+k, y+j, min_column_or_row_numb, max_column_or_row_numb);
        }
}

bool win(int *bombs,int &min_column_or_row_numb, int &max_column_or_row_numb) //checking if u won
{
    using namespace std;
    int mines =0;
    for (int i = min_column_or_row_numb; i<max_column_or_row_numb; i++)
    {
        for (int j = min_column_or_row_numb; j<max_column_or_row_numb; j++)
        {
            if (board[j][i].is_covered == false)
                mines++;
        }
    }
    if (mines == *bombs)
    {
        cout << endl<< "WYGRANA :)" << endl << endl;
        return true;
    }
    return false;
}
bool game_over_menu()
{
    using namespace std;
    enum choices { Exit = 1, PlayAgain };
    int choice;
restart:
    cout << "Koniec gry, co chesz dalej zrobic : " << endl;
    cout << Exit << " - Wyjscie " << endl;
    cout << PlayAgain << " - Zagraj ponownie :) " << endl;
    cin >> choice;

    if (choice == PlayAgain)
        return true;

    else if (choice == Exit)
        return false;
    else
    {
        cout << "Niepoprawne dane, wprowadź ponownie " << endl;
        system("cls");
        goto restart;
    }
}

void play(int *bombs, int &min_column_or_row_numb, int &max_column_or_row_numb)
{
    using namespace std;

    int a, b;
    do
    {
        restart:
        cout << "Podaj wspolrzedne tablicy (od 1 do 10) (najpierw numer kolumny potem wiersza): " << endl;
        cin >> a >> b;
        int y = a - 1;
        int x = b - 1;

        if (y < min_column_or_row_numb || x < min_column_or_row_numb || y > max_column_or_row_numb || x > max_column_or_row_numb)
        {
            cout << "Podales wartosci spoza zakresu, sprobuj jeszcze raz" << endl;
            goto restart;
        }
        system("cls");

        if (board[x][y].value == 9)
        {
            cout << "Przegrales :(" << endl << endl;
            show_board(min_column_or_row_numb, max_column_or_row_numb);//if u lose it shows you the whole board
            break;
        }
        else {
            show_squares(x, y,min_column_or_row_numb, max_column_or_row_numb);
            show_part_of_board(min_column_or_row_numb, max_column_or_row_numb);
        }//it uncoveres the squares according to the rules

    } while (win(bombs, min_column_or_row_numb, max_column_or_row_numb)==false);
}

int main()
{
    using namespace std;
    restart:
    int board_size = 10;
    int min_column_or_row_numb = 0;
    int max_column_or_row_numb = 9;

    int *bombs;
    bombs = new int;
    char again;
    cout << "Podaj ilosc bomb od 0 do 99" << endl;
    cin >> *bombs;

    place_bombs(bombs, min_column_or_row_numb, max_column_or_row_numb);

    if (*bombs >= 0 && *bombs <= 99)
    {
        play(bombs, min_column_or_row_numb, max_column_or_row_numb);
    }

    if (game_over_menu() == true)
    {
        system("cls");
        goto restart;
    }
    else
    return 0;
}