public class Main {
    public static void main(String[] args) {
        Player alice = new Player("Alice", Symbol.X);
        Player bob = new Player("Bob", Symbol.O);

        Game game = new Game(alice, bob, 3);

        System.out.println("========== TIC TAC TOE ==========");

        // Alice (X) completes the top row and wins
        game.makeMove(0, 0);  // X at (0,0)
        game.makeMove(1, 0);  // O at (1,0)
        game.makeMove(0, 1);  // X at (0,1)
        game.makeMove(1, 1);  // O at (1,1)
        game.makeMove(0, 2);  // X at (0,2) - Alice wins!

        game.printBoard();

        System.out.println("Result: " + game.getStatus());
        Player winner = game.getWinner();
        if (winner != null) {
            System.out.println("Winner: " + winner.getName());
        }
    }
}

class Board {
    private final Cell[][] grid;
    private final int size;

    public Board(int size) {
        this.size = size;
        this.grid = new Cell[size][size];
        initializeBoard();
    }

    private void initializeBoard() {
        for (int i = 0; i < size; i++) {
            for (int j = 0; j < size; j++) {
                grid[i][j] = new Cell();
            }
        }
    }

    public void placeSymbol(int row, int col, Symbol symbol) {
        validatePosition(row, col);
        grid[row][col].setSymbol(symbol);
    }

    public boolean isCellEmpty(int row, int col) {
        validatePosition(row, col);
        return grid[row][col].isEmpty();
    }

    public boolean isFull() {
        for (int i = 0; i < size; i++) {
            for (int j = 0; j < size; j++) {
                if (grid[i][j].isEmpty()) {
                    return false;
                }
            }
        }
        return true;
    }

    public Cell getCell(int row, int col) {
        validatePosition(row, col);
        return grid[row][col];
    }

    public int getSize() {
        return size;
    }

    private void validatePosition(int row, int col) {
        if (row < 0 || row >= size || col < 0 || col >= size) {
            throw new InvalidMoveException(
                "Position (" + row + ", " + col + ") is out of bounds"
            );
        }
    }

    public void printBoard() {
        System.out.println();
        for (int i = 0; i < size; i++) {
            for (int j = 0; j < size; j++) {
                System.out.print(" " + grid[i][j].getSymbol().getDisplayChar() + " ");
                if (j < size - 1) System.out.print("|");
            }
            System.out.println();
            if (i < size - 1) {
                System.out.println("-".repeat(size * 4 - 1));
            }
        }
        System.out.println();
    }
}

class Cell {
    private Symbol symbol;

    public Cell() {
        this.symbol = Symbol.EMPTY;
    }

    public Symbol getSymbol() {
        return symbol;
    }

    public void setSymbol(Symbol symbol) {
        this.symbol = symbol;
    }

    public boolean isEmpty() {
        return symbol == Symbol.EMPTY;
    }
}

class Game {
    private final Board board;
    private final Player[] players;
    private int currentPlayerIndex;
    private GameStatus status;

    public Game(Player player1, Player player2, int boardSize) {
        this.board = new Board(boardSize);
        this.players = new Player[]{player1, player2};
        this.currentPlayerIndex = 0;
        this.status = GameStatus.IN_PROGRESS;
    }

    public synchronized void makeMove(int row, int col) {
        // Check if game is already over
        if (status != GameStatus.IN_PROGRESS) {
            throw new InvalidMoveException("Game is already over!");
        }

        // Validate the move
        if (!board.isCellEmpty(row, col)) {
            throw new InvalidMoveException(
                "Cell (" + row + ", " + col + ") is already occupied"
            );
        }

        // Place the symbol
        Player currentPlayer = players[currentPlayerIndex];
        board.placeSymbol(row, col, currentPlayer.getSymbol());

        // Check for win
        if (checkWin(row, col, currentPlayer.getSymbol())) {
            status = (currentPlayer.getSymbol() == Symbol.X)
                ? GameStatus.WINNER_X
                : GameStatus.WINNER_O;
            return;
        }

        // Check for draw
        if (board.isFull()) {
            status = GameStatus.DRAW;
            return;
        }

        // Switch to next player
        currentPlayerIndex = (currentPlayerIndex + 1) % 2;
    }

    private boolean checkWin(int row, int col, Symbol symbol) {
        int size = board.getSize();

        // Check the row of the last move
        boolean win = true;
        for (int c = 0; c < size; c++) {
            if (board.getCell(row, c).getSymbol() != symbol) { win = false; break; }
        }
        if (win) return true;

        // Check the column of the last move
        win = true;
        for (int r = 0; r < size; r++) {
            if (board.getCell(r, col).getSymbol() != symbol) { win = false; break; }
        }
        if (win) return true;

        // Check the main diagonal (only if the move is on it)
        if (row == col) {
            win = true;
            for (int i = 0; i < size; i++) {
                if (board.getCell(i, i).getSymbol() != symbol) { win = false; break; }
            }
            if (win) return true;
        }

        // Check the anti-diagonal (only if the move is on it)
        if (row + col == size - 1) {
            win = true;
            for (int i = 0; i < size; i++) {
                if (board.getCell(i, size - 1 - i).getSymbol() != symbol) { win = false; break; }
            }
            if (win) return true;
        }

        return false;
    }

    public Board getBoard() { return board; }
    public Player getCurrentPlayer() { return players[currentPlayerIndex]; }
    public GameStatus getStatus() { return status; }

    public Player getWinner() {
        if (status == GameStatus.WINNER_X) {
            return players[0].getSymbol() == Symbol.X ? players[0] : players[1];
        } else if (status == GameStatus.WINNER_O) {
            return players[0].getSymbol() == Symbol.O ? players[0] : players[1];
        }
        return null;
    }

    public void printBoard() {
        board.printBoard();
    }
}

class Player {
    private final String name;
    private final Symbol symbol;

    public Player(String name, Symbol symbol) {
        if (symbol == Symbol.EMPTY) {
            throw new IllegalArgumentException("Player cannot have EMPTY symbol");
        }
        this.name = name;
        this.symbol = symbol;
    }

    public String getName() {
        return name;
    }

    public Symbol getSymbol() {
        return symbol;
    }

    @Override
    public String toString() {
        return name + " (" + symbol.getDisplayChar() + ")";
    }
}

enum GameStatus {
    IN_PROGRESS,
    WINNER_X,
    WINNER_O,
    DRAW
}

enum Symbol {
    X('X'),
    O('O'),
    EMPTY('_');

    private final char displayChar;

    Symbol(char displayChar) {
        this.displayChar = displayChar;
    }

    public char getDisplayChar() {
        return displayChar;
    }
}

class InvalidMoveException extends RuntimeException {
    public InvalidMoveException(String message) {
        super(message);
    }
}

from entities.Player import Player
from entities.Game import Game
from enums.Symbol import Symbol


def main():

    alice = Player("Alice", Symbol.X)
    bob = Player("Bob", Symbol.O)

    game = Game(alice, bob, 3)

    print("========== TIC TAC TOE ==========")

    # Alice (X) completes the top row and wins
    game.make_move(0, 0)  # X at (0,0)
    game.make_move(1, 0)  # O at (1,0)
    game.make_move(0, 1)  # X at (0,1)
    game.make_move(1, 1)  # O at (1,1)
    game.make_move(0, 2)  # X at (0,2) - Alice wins!

    game.print_board()

    print("Result:", game.get_status())

    winner = game.get_winner()

    if winner is not None:
        print("Winner:", winner.get_name())


if __name__ == "__main__":
    main()

from entities.Cell import Cell
from enums.Symbol import Symbol
from exceptions.InvalidMoveException import InvalidMoveException


class Board:

    def __init__(self, size):
        self.size = size
        self.grid = [
            [Cell() for _ in range(size)]
            for _ in range(size)
        ]

    def place_symbol(self, row, col, symbol):
        self.validate_position(row, col)
        self.grid[row][col].set_symbol(symbol)

    def is_cell_empty(self, row, col):
        self.validate_position(row, col)
        return self.grid[row][col].is_empty()

    def is_full(self):
        for i in range(self.size):
            for j in range(self.size):
                if self.grid[i][j].is_empty():
                    return False

        return True

    def get_cell(self, row, col):
        self.validate_position(row, col)
        return self.grid[row][col]

    def get_size(self):
        return self.size

    def validate_position(self, row, col):
        if (
            row < 0
            or row >= self.size
            or col < 0
            or col >= self.size
        ):
            raise InvalidMoveException(
                f"Position ({row}, {col}) is out of bounds"
            )

    def print_board(self):
        print()

        for i in range(self.size):

            for j in range(self.size):
                print(
                    f" {self.grid[i][j].get_symbol().get_display_char()} ",
                    end=""
                )

                if j < self.size - 1:
                    print("|", end="")

            print()

            if i < self.size - 1:
                print("-" * (self.size * 4 - 1))

        print()

from enums.Symbol import Symbol


class Cell:

    def __init__(self):
        self.symbol = Symbol.EMPTY

    def get_symbol(self):
        return self.symbol

    def set_symbol(self, symbol):
        self.symbol = symbol

    def is_empty(self):
        return self.symbol == Symbol.EMPTY

from enums.GameStatus import GameStatus
from enums.Symbol import Symbol
from exceptions.InvalidMoveException import InvalidMoveException
from entities.Board import Board


class Game:

    def __init__(self, player1, player2, board_size):
        self.board = Board(board_size)
        self.players = [player1, player2]
        self.current_player_index = 0
        self.status = GameStatus.IN_PROGRESS

    def make_move(self, row, col):

        # Check if game is already over
        if self.status != GameStatus.IN_PROGRESS:
            raise InvalidMoveException("Game is already over!")

        # Validate the move
        if not self.board.is_cell_empty(row, col):
            raise InvalidMoveException(
                f"Cell ({row}, {col}) is already occupied"
            )

        # Place the symbol
        current_player = self.players[self.current_player_index]

        self.board.place_symbol(
            row,
            col,
            current_player.get_symbol()
        )

        # Check for win
        if self.check_win(
            row,
            col,
            current_player.get_symbol()
        ):
            if current_player.get_symbol() == Symbol.X:
                self.status = GameStatus.WINNER_X
            else:
                self.status = GameStatus.WINNER_O

            return

        # Check for draw
        if self.board.is_full():
            self.status = GameStatus.DRAW
            return

        # Switch player
        self.current_player_index = (
            self.current_player_index + 1
        ) % 2

    def check_win(self, row, col, symbol):

        size = self.board.get_size()

        # Check row
        win = True

        for c in range(size):
            if self.board.get_cell(row, c).get_symbol() != symbol:
                win = False
                break

        if win:
            return True

        # Check column
        win = True

        for r in range(size):
            if self.board.get_cell(r, col).get_symbol() != symbol:
                win = False
                break

        if win:
            return True

        # Check main diagonal
        if row == col:
            win = True

            for i in range(size):
                if self.board.get_cell(i, i).get_symbol() != symbol:
                    win = False
                    break

            if win:
                return True

        # Check anti-diagonal
        if row + col == size - 1:
            win = True

            for i in range(size):
                if (
                    self.board
                    .get_cell(i, size - 1 - i)
                    .get_symbol() != symbol
                ):
                    win = False
                    break

            if win:
                return True

        return False

    def get_board(self):
        return self.board

    def get_current_player(self):
        return self.players[self.current_player_index]

    def get_status(self):
        return self.status

    def get_winner(self):

        if self.status == GameStatus.WINNER_X:

            if self.players[0].get_symbol() == Symbol.X:
                return self.players[0]

            return self.players[1]

        elif self.status == GameStatus.WINNER_O:

            if self.players[0].get_symbol() == Symbol.O:
                return self.players[0]

            return self.players[1]

        return None

    def print_board(self):
        self.board.print_board()

from enums.Symbol import Symbol


class Player:

    def __init__(self, name, symbol):
        if symbol == Symbol.EMPTY:
            raise ValueError("Player cannot have EMPTY symbol")

        self.name = name
        self.symbol = symbol

    def get_name(self):
        return self.name

    def get_symbol(self):
        return self.symbol

    def __str__(self):
        return f"{self.name} ({self.symbol.get_display_char()})"

from enum import Enum


class GameStatus(Enum):
    IN_PROGRESS = 1
    WINNER_X = 2
    WINNER_O = 3
    DRAW = 4

from enum import Enum


class Symbol(Enum):
    X = 'X'
    O = 'O'
    EMPTY = '_'

    def get_display_char(self):
        return self.value

class InvalidMoveException(Exception):
    pass

#include <iostream>

#include "entities/Player.h"
#include "entities/Game.h"
#include "enums/Symbol.h"

int main() {

    Player alice("Alice", Symbol::X);

    Player bob("Bob", Symbol::O);

    Game game(&alice, &bob, 3);

    std::cout
        << "========== TIC TAC TOE =========="
        << std::endl;

    // Alice (X) completes the top row and wins

    game.makeMove(0, 0);  // X at (0,0)
    game.makeMove(1, 0);  // O at (1,0)
    game.makeMove(0, 1);  // X at (0,1)
    game.makeMove(1, 1);  // O at (1,1)
    game.makeMove(0, 2);  // X at (0,2) - Alice wins!

    game.printBoard();

    Player* winner = game.getWinner();

    if (winner != nullptr) {
        std::cout
            << "Winner: "
            << winner->getName()
            << std::endl;
    }

    return 0;
}

#include "Board.h"
#include "../exceptions/InvalidMoveException.h"

#include <iostream>
#include <string>

Board::Board(int size) {

    if (size <= 0) {
        throw InvalidMoveException(
            "Board size must be greater than 0"
        );
    }

    this->size = size;

    grid = new Cell*[size];

    for (int i = 0; i < size; i++) {
        grid[i] = new Cell[size];
    }

    initializeBoard();
}

Board::~Board() {

    for (int i = 0; i < size; i++) {
        delete[] grid[i];
    }

    delete[] grid;
}

void Board::initializeBoard() {

    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            grid[i][j] = Cell();
        }
    }
}

void Board::placeSymbol(
    int row,
    int col,
    Symbol symbol
) {
    validatePosition(row, col);

    grid[row][col].setSymbol(symbol);
}

bool Board::isCellEmpty(
    int row,
    int col
) const {

    validatePosition(row, col);

    return grid[row][col].isEmpty();
}

bool Board::isFull() const {

    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {

            if (grid[i][j].isEmpty()) {
                return false;
            }
        }
    }

    return true;
}

Cell& Board::getCell(
    int row,
    int col
) {
    validatePosition(row, col);

    return grid[row][col];
}

const Cell& Board::getCell(
    int row,
    int col
) const {
    validatePosition(row, col);

    return grid[row][col];
}

int Board::getSize() const {
    return size;
}

void Board::validatePosition(
    int row,
    int col
) const {

    if (
        row < 0 ||
        row >= size ||
        col < 0 ||
        col >= size
    ) {
        throw InvalidMoveException(
            "Position (" +
            std::to_string(row) +
            ", " +
            std::to_string(col) +
            ") is out of bounds"
        );
    }
}

void Board::printBoard() const {

    std::cout << std::endl;

    for (int i = 0; i < size; i++) {

        for (int j = 0; j < size; j++) {

            std::cout
                << " "
                << getDisplayChar(
                    grid[i][j].getSymbol()
                )
                << " ";

            if (j < size - 1) {
                std::cout << "|";
            }
        }

        std::cout << std::endl;

        if (i < size - 1) {

            for (int k = 0; k < size * 4 - 1; k++) {
                std::cout << "-";
            }

            std::cout << std::endl;
        }
    }

    std::cout << std::endl;
}

#ifndef GAME_STATUS_H
#define GAME_STATUS_H

enum class GameStatus {
    IN_PROGRESS,
    WINNER_X,
    WINNER_O,
    DRAW
};

#endif

#ifndef INVALID_MOVE_EXCEPTION_H
#define INVALID_MOVE_EXCEPTION_H

#include <stdexcept>
#include <string>

class InvalidMoveException : public std::runtime_error {

public:

    explicit InvalidMoveException(const std::string& message)
        : std::runtime_error(message) {}
};

#endif

#ifndef SYMBOL_H
#define SYMBOL_H

enum class Symbol {
    X,
    O,
    EMPTY
};

inline char getDisplayChar(Symbol symbol) {
    switch (symbol) {
        case Symbol::X:
            return 'X';

        case Symbol::O:
            return 'O';

        case Symbol::EMPTY:
            return '_';
    }

    return '_';
}

#endif

#ifndef BOARD_H
#define BOARD_H

#include "Cell.h"
#include "../enums/Symbol.h"

class Board {

private:
    Cell** grid;
    int size;

    void initializeBoard();

    void validatePosition(int row, int col) const;

public:

    explicit Board(int size);

    ~Board();

    void placeSymbol(
        int row,
        int col,
        Symbol symbol
    );

    bool isCellEmpty(
        int row,
        int col
    ) const;

    bool isFull() const;

    Cell& getCell(
        int row,
        int col
    );

    const Cell& getCell(
        int row,
        int col
    ) const;

    int getSize() const;

    void printBoard() const;
};

#endif

#ifndef CELL_H
#define CELL_H

#include "../enums/Symbol.h"

class Cell {

private:
    Symbol symbol;

public:

    Cell();

    Symbol getSymbol() const;

    void setSymbol(Symbol symbol);

    bool isEmpty() const;
};

#endif

#include "Cell.h"

Cell::Cell() {
    symbol = Symbol::EMPTY;
}

Symbol Cell::getSymbol() const {
    return symbol;
}

void Cell::setSymbol(Symbol symbol) {
    this->symbol = symbol;
}

bool Cell::isEmpty() const {
    return symbol == Symbol::EMPTY;
}

#ifndef GAME_H
#define GAME_H

#include "Board.h"
#include "Player.h"
#include "../enums/GameStatus.h"

#include <mutex>

class Game {

private:
    Board board;

    Player* players[2];

    int currentPlayerIndex;

    GameStatus status;

    std::mutex gameMutex;

    bool checkWin(
        int row,
        int col,
        Symbol symbol
    );

public:

    Game(
        Player* player1,
        Player* player2,
        int boardSize
    );

    void makeMove(
        int row,
        int col
    );

    Board& getBoard();

    Player* getCurrentPlayer();

    GameStatus getStatus() const;

    Player* getWinner();

    void printBoard();
};

#endif

#ifndef PLAYER_H
#define PLAYER_H

#include <string>
#include "../enums/Symbol.h"

class Player {

private:
    std::string name;
    Symbol symbol;

public:

    Player(const std::string& name, Symbol symbol);

    std::string getName() const;

    Symbol getSymbol() const;
};

#endif

#include "Game.h"
#include "../exceptions/InvalidMoveException.h"

Game::Game(
    Player* player1,
    Player* player2,
    int boardSize
)
    : board(boardSize) {

    players[0] = player1;
    players[1] = player2;

    currentPlayerIndex = 0;

    status = GameStatus::IN_PROGRESS;
}

void Game::makeMove(
    int row,
    int col
) {

    std::lock_guard<std::mutex> lock(gameMutex);

    // Check if game is already over
    if (status != GameStatus::IN_PROGRESS) {
        throw InvalidMoveException(
            "Game is already over!"
        );
    }

    // Validate move
    if (!board.isCellEmpty(row, col)) {
        throw InvalidMoveException(
            "Cell (" +
            std::to_string(row) +
            ", " +
            std::to_string(col) +
            ") is already occupied"
        );
    }

    // Place symbol
    Player* currentPlayer =
        players[currentPlayerIndex];

    board.placeSymbol(
        row,
        col,
        currentPlayer->getSymbol()
    );

    // Check win
    if (
        checkWin(
            row,
            col,
            currentPlayer->getSymbol()
        )
    ) {

        if (currentPlayer->getSymbol() == Symbol::X) {
            status = GameStatus::WINNER_X;
        } else {
            status = GameStatus::WINNER_O;
        }

        return;
    }

    // Check draw
    if (board.isFull()) {
        status = GameStatus::DRAW;
        return;
    }

    // Switch player
    currentPlayerIndex =
        (currentPlayerIndex + 1) % 2;
}

bool Game::checkWin(
    int row,
    int col,
    Symbol symbol
) {

    int size = board.getSize();

    // Check row
    bool win = true;

    for (int c = 0; c < size; c++) {

        if (
            board.getCell(row, c).getSymbol()
            != symbol
        ) {
            win = false;
            break;
        }
    }

    if (win) {
        return true;
    }

    // Check column
    win = true;

    for (int r = 0; r < size; r++) {

        if (
            board.getCell(r, col).getSymbol()
            != symbol
        ) {
            win = false;
            break;
        }
    }

    if (win) {
        return true;
    }

    // Main diagonal
    if (row == col) {

        win = true;

        for (int i = 0; i < size; i++) {

            if (
                board.getCell(i, i).getSymbol()
                != symbol
            ) {
                win = false;
                break;
            }
        }

        if (win) {
            return true;
        }
    }

    // Anti-diagonal
    if (row + col == size - 1) {

        win = true;

        for (int i = 0; i < size; i++) {

            if (
                board
                    .getCell(i, size - 1 - i)
                    .getSymbol()
                != symbol
            ) {
                win = false;
                break;
            }
        }

        if (win) {
            return true;
        }
    }

    return false;
}

Board& Game::getBoard() {
    return board;
}

Player* Game::getCurrentPlayer() {
    return players[currentPlayerIndex];
}

GameStatus Game::getStatus() const {
    return status;
}

Player* Game::getWinner() {

    if (status == GameStatus::WINNER_X) {

        if (players[0]->getSymbol() == Symbol::X) {
            return players[0];
        }

        return players[1];
    }

    if (status == GameStatus::WINNER_O) {

        if (players[0]->getSymbol() == Symbol::O) {
            return players[0];
        }

        return players[1];
    }

    return nullptr;
}

void Game::printBoard() {
    board.printBoard();
}

#include "Player.h"
#include "../exceptions/InvalidMoveException.h"

Player::Player(
    const std::string& name,
    Symbol symbol
) {
    if (symbol == Symbol::EMPTY) {
        throw InvalidMoveException(
            "Player cannot have EMPTY symbol"
        );
    }

    this->name = name;
    this->symbol = symbol;
}

std::string Player::getName() const {
    return name;
}

Symbol Player::getSymbol() const {
    return symbol;
}

package main

import (
	"fmt"

	"tic-tac-toe/entities"
	"tic-tac-toe/enums"
)

func main() {

	alice, err := entities.NewPlayer(
		"Alice",
		enums.X,
	)

	if err != nil {
		fmt.Println(err)
		return
	}

	bob, err := entities.NewPlayer(
		"Bob",
		enums.O,
	)

	if err != nil {
		fmt.Println(err)
		return
	}

	game := entities.NewGame(
		alice,
		bob,
		3,
	)

	fmt.Println(
		"========== TIC TAC TOE ==========",
	)

	// Alice (X) completes the top row and wins

	err = game.MakeMove(0, 0) // X at (0,0)
	if err != nil {
		fmt.Println(err)
		return
	}

	err = game.MakeMove(1, 0) // O at (1,0)
	if err != nil {
		fmt.Println(err)
		return
	}

	err = game.MakeMove(0, 1) // X at (0,1)
	if err != nil {
		fmt.Println(err)
		return
	}

	err = game.MakeMove(1, 1) // O at (1,1)
	if err != nil {
		fmt.Println(err)
		return
	}

	err = game.MakeMove(0, 2) // X at (0,2) - Alice wins!
	if err != nil {
		fmt.Println(err)
		return
	}

	game.PrintBoard()

	winner := game.GetWinner()

	if winner != nil {
		fmt.Println(
			"Winner:",
			winner.GetName(),
		)
	}
}

package entities

import (
	"fmt"
	"strings"

	"tic-tac-toe/enums"
	"tic-tac-toe/exceptions"
)

type Board struct {
	grid [][]*Cell
	size int
}

func NewBoard(size int) *Board {

	board := &Board{
		size: size,
		grid: make([][]*Cell, size),
	}

	board.initializeBoard()

	return board
}

func (b *Board) initializeBoard() {

	for i := 0; i < b.size; i++ {

		b.grid[i] = make([]*Cell, b.size)

		for j := 0; j < b.size; j++ {
			b.grid[i][j] = NewCell()
		}
	}
}

func (b *Board) PlaceSymbol(
	row int,
	col int,
	symbol enums.Symbol,
) error {

	if err := b.validatePosition(row, col); err != nil {
		return err
	}

	b.grid[row][col].SetSymbol(symbol)

	return nil
}

func (b *Board) IsCellEmpty(
	row int,
	col int,
) (bool, error) {

	if err := b.validatePosition(row, col); err != nil {
		return false, err
	}

	return b.grid[row][col].IsEmpty(), nil
}

func (b *Board) IsFull() bool {

	for i := 0; i < b.size; i++ {

		for j := 0; j < b.size; j++ {

			if b.grid[i][j].IsEmpty() {
				return false
			}
		}
	}

	return true
}

func (b *Board) GetCell(
	row int,
	col int,
) (*Cell, error) {

	if err := b.validatePosition(row, col); err != nil {
		return nil, err
	}

	return b.grid[row][col], nil
}

func (b *Board) GetSize() int {
	return b.size
}

func (b *Board) validatePosition(
	row int,
	col int,
) error {

	if (
		row < 0 ||
		row >= b.size ||
		col < 0 ||
		col >= b.size
	) {
		return exceptions.NewInvalidMoveException(
			fmt.Sprintf(
				"Position (%d, %d) is out of bounds",
				row,
				col,
			),
		)
	}

	return nil
}

func (b *Board) PrintBoard() {

	fmt.Println()

	for i := 0; i < b.size; i++ {

		for j := 0; j < b.size; j++ {

			fmt.Printf(
				" %c ",
				b.grid[i][j].GetSymbol().GetDisplayChar(),
			)

			if j < b.size-1 {
				fmt.Print("|")
			}
		}

		fmt.Println()

		if i < b.size-1 {
			fmt.Println(
				strings.Repeat(
					"-",
					b.size*4-1,
				),
			)
		}
	}

	fmt.Println()
}

package enums

type Symbol int

const (
	X Symbol = iota
	O
	EMPTY
)

func (s Symbol) GetDisplayChar() rune {
	switch s {
	case X:
		return 'X'
	case O:
		return 'O'
	case EMPTY:
		return '_'
	default:
		return '_'
	}
}

package exceptions

type InvalidMoveException struct {
	Message string
}

func (e *InvalidMoveException) Error() string {
	return e.Message
}

func NewInvalidMoveException(message string) error {
	return &InvalidMoveException{
		Message: message,
	}
}

package entities

import "tic-tac-toe/enums"

type Cell struct {
	symbol enums.Symbol
}

func NewCell() *Cell {
	return &Cell{
		symbol: enums.EMPTY,
	}
}

func (c *Cell) GetSymbol() enums.Symbol {
	return c.symbol
}

func (c *Cell) SetSymbol(symbol enums.Symbol) {
	c.symbol = symbol
}

func (c *Cell) IsEmpty() bool {
	return c.symbol == enums.EMPTY
}

package entities

import (
	"fmt"
	"sync"

	"tic-tac-toe/enums"
	"tic-tac-toe/exceptions"
)

type Game struct {
	board              *Board
	players            [2]*Player
	currentPlayerIndex int
	status             enums.GameStatus

	mutex sync.Mutex
}

func NewGame(
	player1 *Player,
	player2 *Player,
	boardSize int,
) *Game {

	return &Game{
		board: NewBoard(boardSize),

		players: [2]*Player{
			player1,
			player2,
		},

		currentPlayerIndex: 0,

		status: enums.IN_PROGRESS,
	}
}

func (g *Game) MakeMove(
	row int,
	col int,
) error {

	g.mutex.Lock()
	defer g.mutex.Unlock()

	// Check if game is already over
	if g.status != enums.IN_PROGRESS {
		return exceptions.NewInvalidMoveException(
			"Game is already over!",
		)
	}

	// Validate the move
	isEmpty, err := g.board.IsCellEmpty(row, col)

	if err != nil {
		return err
	}

	if !isEmpty {
		return exceptions.NewInvalidMoveException(
			fmt.Sprintf(
				"Cell (%d, %d) is already occupied",
				row,
				col,
			),
		)
	}

	// Place the symbol
	currentPlayer :=
		g.players[g.currentPlayerIndex]

	err = g.board.PlaceSymbol(
		row,
		col,
		currentPlayer.GetSymbol(),
	)

	if err != nil {
		return err
	}

	// Check for win
	if g.checkWin(
		row,
		col,
		currentPlayer.GetSymbol(),
	) {

		if currentPlayer.GetSymbol() == enums.X {
			g.status = enums.WINNER_X
		} else {
			g.status = enums.WINNER_O
		}

		return nil
	}

	// Check for draw
	if g.board.IsFull() {
		g.status = enums.DRAW
		return nil
	}

	// Switch to next player
	g.currentPlayerIndex =
		(g.currentPlayerIndex + 1) % 2

	return nil
}

func (g *Game) checkWin(
	row int,
	col int,
	symbol enums.Symbol,
) bool {

	size := g.board.GetSize()

	// Check the row of the last move
	win := true

	for c := 0; c < size; c++ {

		cell, _ := g.board.GetCell(row, c)

		if cell.GetSymbol() != symbol {
			win = false
			break
		}
	}

	if win {
		return true
	}

	// Check the column of the last move
	win = true

	for r := 0; r < size; r++ {

		cell, _ := g.board.GetCell(r, col)

		if cell.GetSymbol() != symbol {
			win = false
			break
		}
	}

	if win {
		return true
	}

	// Check the main diagonal
	if row == col {

		win = true

		for i := 0; i < size; i++ {

			cell, _ := g.board.GetCell(i, i)

			if cell.GetSymbol() != symbol {
				win = false
				break
			}
		}

		if win {
			return true
		}
	}

	// Check the anti-diagonal
	if row+col == size-1 {

		win = true

		for i := 0; i < size; i++ {

			cell, _ := g.board.GetCell(
				i,
				size-1-i,
			)

			if cell.GetSymbol() != symbol {
				win = false
				break
			}
		}

		if win {
			return true
		}
	}

	return false
}

func (g *Game) GetBoard() *Board {
	return g.board
}

func (g *Game) GetCurrentPlayer() *Player {
	return g.players[g.currentPlayerIndex]
}

func (g *Game) GetStatus() enums.GameStatus {
	return g.status
}

func (g *Game) GetWinner() *Player {

	if g.status == enums.WINNER_X {

		if g.players[0].GetSymbol() == enums.X {
			return g.players[0]
		}

		return g.players[1]
	}

	if g.status == enums.WINNER_O {

		if g.players[0].GetSymbol() == enums.O {
			return g.players[0]
		}

		return g.players[1]
	}

	return nil
}

func (g *Game) PrintBoard() {
	g.board.PrintBoard()
}

package entities

import (
	"fmt"

	"tic-tac-toe/enums"
	"tic-tac-toe/exceptions"
)

type Player struct {
	name   string
	symbol enums.Symbol
}

func NewPlayer(
	name string,
	symbol enums.Symbol,
) (*Player, error) {

	if symbol == enums.EMPTY {
		return nil, exceptions.NewInvalidMoveException(
			"Player cannot have EMPTY symbol",
		)
	}

	return &Player{
		name:   name,
		symbol: symbol,
	}, nil
}

func (p *Player) GetName() string {
	return p.name
}

func (p *Player) GetSymbol() enums.Symbol {
	return p.symbol
}

func (p *Player) String() string {
	return fmt.Sprintf(
		"%s (%c)",
		p.name,
		p.symbol.GetDisplayChar(),
	)
}

package enums

type GameStatus int

const (
	IN_PROGRESS GameStatus = iota
	WINNER_X
	WINNER_O
	DRAW
)