/* "Гра х0. Перший гравець вибирається випадковим чином. Можна використ глоб масив." */

#include <iostream>
#include <ctime>
//#include <string>
#include <windows.h>
//#include <conio.h>
#include <cstdio>

using namespace std;

// global variables
const int FIELD_SIZE = 3, WIN_LINE_LENGTH = 3;
enum key { UP, DOWN, LEFT, RIGHT, ENTER, ESCAPE };
char game_field[FIELD_SIZE][FIELD_SIZE];
int pointer_row = 0, pointer_col = 0;

// function prototypes
char pointer(int row, int col);
void drawRow(char symbol, char pointer);
int choiceFirstPlayer();
void paintGameField();
bool movePointer(int direction);
short getKeyPressed();
bool putPlayerMark(char player_mark);
bool vitalComputerMove(char mark, char computer_mark);
void computerMove(char player_mark, char computer_mark);
bool checkFreeCorner(char computer_mark);
bool checkFreeCell(char computer_mark);
int checkWinner(char computer_mark, char player_mark);


int main()
{
    cout.sync_with_stdio(false);
    srand(unsigned(time(0)));

    for (int i = 0; i < FIELD_SIZE; i++)
        for (int j = 0; j < FIELD_SIZE; j++)
            game_field[i][j] = ' ';

    // choose first player, set marks
    int first = choiceFirstPlayer();
    char player_mark, computer_mark;
    if (first == 0)
    {
        computer_mark = 'O';
        player_mark = 'X';
    }
    else
    {
        computer_mark = 'X';
        player_mark = 'O';
        computerMove(player_mark, computer_mark);
    }

    short key;
    bool exit = false, action = false;
    int winner;
    paintGameField();
    do {
        // take keyboard input
        key = getKeyPressed();
        // do something - move_cursor, put X or O, etc.
        switch (key)
        {
        case ESCAPE:
            exit = true;
            break;
        case ENTER:
            action = putPlayerMark(player_mark);
            if (action)
            {
                winner = checkWinner(computer_mark, player_mark);
                // if not winner, computerMove()
                if (winner == -1)
                {
                    computerMove(player_mark, computer_mark);
                    winner = checkWinner(computer_mark, player_mark);
                    if (winner != -1)
                        exit = true;
                }
                else
                    exit = true;
            }
            break;
        default:
            action = movePointer(key);
        }
        if (action)
        {
            system("cls");
            paintGameField();
        }
        // continue loop if game is not finished
        Sleep(50);
    } while (!exit);
    if (winner == 0)
        cout << "\n\tYOU LOSE\n";
    else if (winner == 1)
        cout << "\n\tYUO WIN\n";
    else
        cout << "\n\tDRAW\n";
    return 0;
}

int choiceFirstPlayer()
{
    int player = rand() % 2;
    return player;
}

short getKeyPressed()
{
    if (GetAsyncKeyState(VK_UP) < 0)
        return UP;
    else if (GetAsyncKeyState(VK_DOWN) < 0)
        return DOWN;
    else if (GetAsyncKeyState(VK_LEFT) < 0)
        return LEFT;
    else if (GetAsyncKeyState(VK_RIGHT) < 0)
        return RIGHT;
    else if (GetAsyncKeyState(VK_ESCAPE) < 0)
        return ESCAPE;
    else if (GetAsyncKeyState(VK_RETURN) < 0)
        return ENTER;
    else
        return -1;
}

void drawRow(int row)
{
    for (int i = 0; i < FIELD_SIZE; i++)
        cout << " ___" << " ";
    cout << endl;
    for (int i = 0; i < FIELD_SIZE; i++)
        cout << "|" << pointer(row, i) << "  |";
    cout << endl;
    for (int i = 0; i < FIELD_SIZE; i++)
        cout << "| " << game_field[row][i] << " |";
    cout << endl;
    for (int i = 0; i < FIELD_SIZE; i++)
    cout << "|___|";
    cout << endl;
}

void paintGameField()
{
    cout << "\tNoughts and Crosses game\n\n";

    for (int i = 0; i < FIELD_SIZE; i++)
        drawRow(i);

}

bool movePointer(int direction)
{
    bool move = false;
    switch (direction)
    {
    case UP:
        pointer_row--;
        if (pointer_row < 0)
            pointer_row = FIELD_SIZE - 1;
        move = true;
        break;
    case DOWN:
        pointer_row++;
        if (pointer_row > FIELD_SIZE - 1)
            pointer_row = 0;
        move = true;
        break;
    case LEFT:
        pointer_col--;
        if (pointer_col < 0)
            pointer_col = FIELD_SIZE - 1;
        move = true;
        break;
    case RIGHT:
        pointer_col++;
        if (pointer_col > FIELD_SIZE - 1)
            pointer_col = 0;
        move = true;
        break;
    }
    return move;
}

char pointer(int row, int col)
{
    char pointer;
    if (row == pointer_row && col == pointer_col)
        pointer = '*';
    else
        pointer = ' ';
    return pointer;
} 

bool putPlayerMark(char player_mark)
{
    bool player_turn = false;
    if (game_field[pointer_row][pointer_col] == ' ')
    {
        game_field[pointer_row][pointer_col] = player_mark;
        player_turn = true;
    }
    return player_turn;
}

void computerMove(char player_mark, char computer_mark)
{
    bool computer_move = false;
    // check if computer can win with next move
    computer_move = vitalComputerMove(computer_mark, computer_mark);

    // check if computer must do a defensive move
    if (!computer_move)
        computer_move = vitalComputerMove(player_mark, computer_mark);

    //  make non-vital computer move
    if (!computer_move)
        computer_move = checkFreeCorner(computer_mark);

    if (!computer_move)
        computer_move = checkFreeCell(computer_mark);
}

/*
   Find if computer can win with next move or make a defensive move
*/
bool vitalComputerMove(char mark, char computer_mark)
{
    int count_player_mark;
    int free_col, free_row;
    bool computer_move = false;

    //check for vital computer move in rows
    for (int i = 0; i < FIELD_SIZE; i++)
    {
        count_player_mark = 0;
        free_col = -1;
        for (int j = 0; j < FIELD_SIZE; j++)
        {
            if (game_field[i][j] == mark)
                count_player_mark++;
            else if (game_field[i][j] == ' ')
                free_col = j;
        }
        if (count_player_mark == 2 && free_col != -1)
        {
            game_field[i][free_col] = computer_mark;
            computer_move = true;
            break;
        }
    }
    if (computer_move)
        return computer_move;

    //check for vital computer move in main diagonal
    count_player_mark = 0;
    for (int i = 0; i < FIELD_SIZE; i++)
    {
        free_col = -1;
        free_row = -1;
        if (game_field[i][i] == mark)
            count_player_mark++;
        else if (game_field[i][i] == ' ')
            free_row = free_col = i;
    }
    if (count_player_mark == 2 && free_col != -1 && free_row != -1)
    {
        game_field[free_row][free_col] = computer_mark;
        // exit from function, no sense to check other variants
        computer_move = true;
        return computer_move;
    }

    count_player_mark = 0;
    // check for vital computer move in side diagonal
    free_col = -1;
    free_row = -1;
    for (int i = 0; i < FIELD_SIZE; i++)
    {
        if (game_field[i][FIELD_SIZE - 1 - i] == mark)
            count_player_mark++;
        else if (game_field[i][FIELD_SIZE - 1 - i] == ' ')
        {
            free_row = i;
            free_col = FIELD_SIZE - 1 - i;
        }
    }
    if (count_player_mark == 2 && free_col != -1 && free_row != -1)
    {
        game_field[free_row][free_col] = computer_mark;
        // exit from function, no sense to check other variants
        computer_move = true;
        return computer_move;
    }

    // check for vital computer move in columns
    for (int j = 0; j < FIELD_SIZE; j++)
    {
        free_row = -1;
        count_player_mark = 0;
        for (int i = 0; i < FIELD_SIZE; i++)
        {
            if (game_field[i][j] == mark)
                count_player_mark++;
            else if (game_field[i][j] == ' ')
                free_row = i;
        }
        if (count_player_mark == 2 && free_row != -1)
        {
            game_field[free_row][j] = computer_mark;
            computer_move = true;
            break;
        }
    }
    if (computer_move)
        return computer_move;

    return computer_move;
}

bool checkFreeCorner(char computer_mark)
{
    bool computer_move = false;
    if (game_field[FIELD_SIZE / 2][FIELD_SIZE / 2] == ' ')
    {
        game_field[FIELD_SIZE / 2][FIELD_SIZE / 2] = computer_mark;
        computer_move = true;
    }
    else if (game_field[0][0] == ' ')
    {
        game_field[0][0] = computer_mark;
        computer_move = true;
    }
    else if (game_field[FIELD_SIZE - 1][FIELD_SIZE - 1] == ' ')
    {
        game_field[FIELD_SIZE - 1][FIELD_SIZE - 1] = computer_mark;
        computer_move = true;
    }
    else if (game_field[FIELD_SIZE - 1][0] == ' ')
    {
        game_field[FIELD_SIZE - 1][0] = computer_mark;
        computer_move = true;
    }
    else if (game_field[0][FIELD_SIZE - 1] == ' ')
    {
        game_field[0][FIELD_SIZE - 1] = computer_mark;
        computer_move = true;
    }

    return computer_move;
}

bool checkFreeCell(char computer_mark)
{
    bool computer_move = false;
    for (int i = 0; i < FIELD_SIZE; i++)
    {
        for (int j = 0; j < FIELD_SIZE; j++)
        {
            if (game_field[i][j] == ' ')
            {
                game_field[i][j] = computer_mark;
                computer_move = true;
                return computer_move;
            }
        }
    }
    return computer_move;
}

int checkWinner(char computer_mark, char player_mark)
{
    int winner = -1;
    char mark;
    int count_mark;

    // check winner in row
    for (int i = 0; i < FIELD_SIZE; i++)
    {
        count_mark = 1;
        mark = game_field[i][0];
        for (int j = 1; j < FIELD_SIZE; j++)
        {
            if (game_field[i][j] == mark)
                count_mark++;
            else
                break;
        }
        if (count_mark == WIN_LINE_LENGTH)
        {
            if (mark == computer_mark)
            {
                winner = 0;
                return winner;
            }
            else if (mark == player_mark)
            {
                winner = 1;
                return winner;
            }
        }
    }

    // check winner in main diagonal
    mark = game_field[0][0];
    count_mark = 1;
    for (int i = 1; i < FIELD_SIZE; i++)
    {
        if (game_field[i][i] == mark)
            count_mark++;
    }
    if (count_mark == WIN_LINE_LENGTH)
    {
        if (mark == computer_mark)
        {
            winner = 0;
            return winner;
        }
        else if (mark == player_mark)
        {
            winner = 1;
            return winner;
        }
    }

    // check winner in side diagonal
    mark = game_field[0][FIELD_SIZE - 1];
    count_mark = 1;
    for (int i = 1; i < FIELD_SIZE; i++)
    {
        if (game_field[i][FIELD_SIZE - 1 - i] == mark)
            count_mark++;
    }
    if (count_mark == WIN_LINE_LENGTH)
    {
        if (mark == computer_mark)
        {
            winner = 0;
            return winner;
        }
        else if (mark == player_mark)
        {
            winner = 1;
            return winner;
        }
    }

    // chek winner in columns
    for (int j = 0; j < FIELD_SIZE; j++)
    {
        count_mark = 1;
        mark = game_field[0][j];
        for (int i = 1; i < FIELD_SIZE; i++)
        {
            if (game_field[i][j] == mark)
                count_mark++;
            else
                break;
        }
        if (count_mark == WIN_LINE_LENGTH)
        {
            if (mark == computer_mark)
            {
                winner = 0;
                return winner;
            }
            else if (mark == player_mark)
            {
                winner = 1;
                return winner;
            }
        }
    }

    // check for a draw
    count_mark = 0;
    for (int i = 0; i < FIELD_SIZE; i++)
    {
        for (int j = 0; j < FIELD_SIZE; j++)
        {
            if (game_field[i][j] != ' ')
                count_mark++;
            else
                break;
        }
    }
    if (count_mark == FIELD_SIZE * FIELD_SIZE)
        winner = 2;

    return winner;
}