Tic-Tac-Toe

public enum Mark {
    X,
    O
}

public enum GameStatus {
    IN_PROGRESS,
    X_WON,
    O_WON,
    DRAW
}

public enum MoveResult {
    ACCEPTED,
    NOT_YOUR_TURN,
    OUT_OF_BOUNDS,
    CELL_OCCUPIED,
    GAME_ALREADY_OVER
}

import java.util.Objects;

public final class Player {
    private final String name;
    private final Mark mark;

    public Player(String name, Mark mark) {
        if (name == null || name.isBlank()) {
            throw new IllegalArgumentException("name is required");
        }
        this.name = name;
        this.mark = Objects.requireNonNull(mark);
    }

    public String getName() {
        return name;
    }

    public Mark getMark() {
        return mark;
    }

    @Override
    public String toString() {
        return name + " (" + mark + ")";
    }
}

import java.util.Arrays;

public final class Board {
    public static final int SIZE = 3;
    private final Mark[][] cells = new Mark[SIZE][SIZE];

    public boolean place(int row, int column, Mark mark) {
        if (!isInside(row, column) || mark == null) return false;
        if (cells[row][column] != null) return false;
        cells[row][column] = mark;
        return true;
    }

    public boolean isInside(int row, int column) {
        return row >= 0 && row < SIZE && column >= 0 && column < SIZE;
    }

    public boolean hasWinningLine(Mark mark) {
        for (int index = 0; index < SIZE; index++) {
            if (cells[index][0] == mark
                    && cells[index][1] == mark
                    && cells[index][2] == mark) {
                return true;
            }
            if (cells[0][index] == mark
                    && cells[1][index] == mark
                    && cells[2][index] == mark) {
                return true;
            }
        }

        boolean mainDiagonal = cells[0][0] == mark
                && cells[1][1] == mark
                && cells[2][2] == mark;
        boolean otherDiagonal = cells[0][2] == mark
                && cells[1][1] == mark
                && cells[2][0] == mark;

        return mainDiagonal || otherDiagonal;
    }

    public boolean isFull() {
        for (Mark[] row : cells) {
            for (Mark cell : row) {
                if (cell == null) return false;
            }
        }
        return true;
    }

    public Mark getMark(int row, int column) {
        if (!isInside(row, column)) {
            throw new IndexOutOfBoundsException("Cell is outside the board");
        }
        return cells[row][column];
    }

    public void clear() {
        for (Mark[] row : cells) {
            Arrays.fill(row, null);
        }
    }

    @Override
    public String toString() {
        StringBuilder output = new StringBuilder();
        for (int row = 0; row < SIZE; row++) {
            for (int column = 0; column < SIZE; column++) {
                Mark mark = cells[row][column];
                output.append(mark == null ? "." : mark);
                if (column < SIZE - 1) output.append(" ");
            }
            output.append(System.lineSeparator());
        }
        return output.toString();
    }
}

import java.util.Objects;

public final class Game {
    private final Board board;
    private final Player playerX;
    private final Player playerO;
    private Player currentPlayer;
    private Player winner;
    private GameStatus status;

    public Game(Player first, Player second) {
        Objects.requireNonNull(first);
        Objects.requireNonNull(second);
        if (first.getMark() == second.getMark()) {
            throw new IllegalArgumentException("Players need different marks");
        }

        this.playerX = first.getMark() == Mark.X ? first : second;
        this.playerO = first.getMark() == Mark.O ? first : second;
        this.board = new Board();
        reset();
    }

    public MoveResult makeMove(Player player, int row, int column) {
        if (status != GameStatus.IN_PROGRESS) {
            return MoveResult.GAME_ALREADY_OVER;
        }
        if (player != currentPlayer) {
            return MoveResult.NOT_YOUR_TURN;
        }
        if (!board.isInside(row, column)) {
            return MoveResult.OUT_OF_BOUNDS;
        }
        if (!board.place(row, column, player.getMark())) {
            return MoveResult.CELL_OCCUPIED;
        }

        if (board.hasWinningLine(player.getMark())) {
            winner = player;
            status = player.getMark() == Mark.X
                    ? GameStatus.X_WON
                    : GameStatus.O_WON;
        } else if (board.isFull()) {
            status = GameStatus.DRAW;
        } else {
            currentPlayer = currentPlayer == playerX ? playerO : playerX;
        }

        return MoveResult.ACCEPTED;
    }

    public void reset() {
        board.clear();
        currentPlayer = playerX;
        winner = null;
        status = GameStatus.IN_PROGRESS;
    }

    public Board getBoard() {
        return board;
    }

    public Player getCurrentPlayer() {
        return currentPlayer;
    }

    public Player getWinner() {
        return winner;
    }

    public GameStatus getStatus() {
        return status;
    }
}

public final class TicTacToeDemo {
    public static void main(String[] args) {
        Player alice = new Player("Alice", Mark.X);
        Player bob = new Player("Bob", Mark.O);
        Game game = new Game(alice, bob);

        play(game, alice, 0, 0);
        play(game, bob,   1, 0);
        play(game, alice, 0, 1);
        play(game, bob,   1, 1);
        play(game, alice, 0, 2);

        System.out.println(game.getBoard());
        System.out.println("Status: " + game.getStatus());
        System.out.println("Winner: " + game.getWinner());
    }

    private static void play(Game game, Player player, int row, int column) {
        MoveResult result = game.makeMove(player, row, column);
        System.out.printf("%s -> (%d,%d): %s%n",
                player.getName(), row, column, result);
    }
}