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

1class Symbol(Enum):
2    X = 'X'
3    O = 'O'
4    EMPTY = '_'
5    
6    def get_char(self):
7        return self.value

1class InvalidMoveException(Exception):
2    def __init__(self, message):
3        super().__init__(message)

1class Player:
2    def __init__(self, name: str, symbol: Symbol):
3        self.name = name
4        self.symbol = symbol
5    
6    def get_name(self):
7        return self.name
8    
9    def get_symbol(self):
10        return self.symbol

1class Cell:
2    def __init__(self):
3        self.symbol = Symbol.EMPTY
4    
5    def get_symbol(self):
6        return self.symbol
7    
8    def set_symbol(self, symbol: Symbol):
9        self.symbol = symbol

1class Board:
2    def __init__(self, size: int):
3        self.size = size
4        self.moves_count = 0
5        self.board = []
6        self.initialize_board()
7    
8    def initialize_board(self):
9        for row in range(self.size):
10            board_row = []
11            for col in range(self.size):
12                board_row.append(Cell())
13            self.board.append(board_row)
14    
15    def place_symbol(self, row: int, col: int, symbol: Symbol) -> bool:
16        if row < 0 or row >= self.size or col < 0 or col >= self.size:
17            raise InvalidMoveException("Invalid position: out of bounds.")
18        if self.board[row][col].get_symbol() != Symbol.EMPTY:
19            raise InvalidMoveException("Invalid position: cell is already occupied.")
20        
21        self.board[row][col].set_symbol(symbol)
22        self.moves_count += 1
23        return True
24    
25    def get_cell(self, row: int, col: int) -> Optional[Cell]:
26        if row < 0 or row >= self.size or col < 0 or col >= self.size:
27            return None
28        return self.board[row][col]
29    
30    def is_full(self) -> bool:
31        return self.moves_count == self.size * self.size
32    
33    def print_board(self):
34        print("-------------")
35        for i in range(self.size):
36            print("| ", end="")
37            for j in range(self.size):
38                symbol = self.board[i][j].get_symbol()
39                print(f"{symbol.get_char()} | ", end="")
40            print("\n-------------")
41    
42    def get_size(self):
43        return self.size

1class WinningStrategy(ABC):
2    @abstractmethod
3    def check_winner(self, board: Board, player: Player) -> bool:
4        pass
5
6class RowWinningStrategy(WinningStrategy):
7    def check_winner(self, board: Board, player: Player) -> bool:
8        for row in range(board.get_size()):
9            row_win = True
10            for col in range(board.get_size()):
11                if board.get_cell(row, col).get_symbol() != player.get_symbol():
12                    row_win = False
13                    break
14            if row_win:
15                return True
16        return False
17
18class ColumnWinningStrategy(WinningStrategy):
19    def check_winner(self, board: Board, player: Player) -> bool:
20        for col in range(board.get_size()):
21            col_win = True
22            for row in range(board.get_size()):
23                if board.get_cell(row, col).get_symbol() != player.get_symbol():
24                    col_win = False
25                    break
26            if col_win:
27                return True
28        return False
29
30class DiagonalWinningStrategy(WinningStrategy):
31    def check_winner(self, board: Board, player: Player) -> bool:
32        # Main diagonal
33        main_diag_win = True
34        for i in range(board.get_size()):
35            if board.get_cell(i, i).get_symbol() != player.get_symbol():
36                main_diag_win = False
37                break
38        if main_diag_win:
39            return True
40        
41        # Anti-diagonal
42        anti_diag_win = True
43        for i in range(board.get_size()):
44            if board.get_cell(i, board.get_size() - 1 - i).get_symbol() != player.get_symbol():
45                anti_diag_win = False
46                break
47        return anti_diag_win

1class GameObserver(ABC):
2    @abstractmethod
3    def update(self, game):
4        pass

1class GameSubject(ABC):
2    def __init__(self):
3        self.observers = []
4    
5    def add_observer(self, observer: GameObserver):
6        self.observers.append(observer)
7    
8    def remove_observer(self, observer: GameObserver):
9        self.observers.remove(observer)
10    
11    def notify_observers(self):
12        for observer in self.observers:
13            observer.update(self)

1class Scoreboard(GameObserver):
2    def __init__(self):
3        self.scores = {}
4    
5    def update(self, game):
6        # The scoreboard only cares about finished games with a winner
7        if game.get_winner() is not None:
8            winner_name = game.get_winner().get_name()
9            self.scores[winner_name] = self.scores.get(winner_name, 0) + 1
10            print(f"[Scoreboard] {winner_name} wins! Their new score is {self.scores[winner_name]}.")
11    
12    def print_scores(self):
13        print("\n--- Overall Scoreboard ---")
14        if not self.scores:
15            print("No games with a winner have been played yet.")
16            return
17        
18        for player_name, score in self.scores.items():
19            print(f"Player: {player_name:<10} | Wins: {score}")
20        print("--------------------------\n")

1class GameState(ABC):
2    @abstractmethod
3    def handle_move(self, game, player: Player, row: int, col: int):
4        pass
5
6class InProgressState(GameState):
7    def handle_move(self, game, player: Player, row: int, col: int):
8        if game.get_current_player() != player:
9            raise InvalidMoveException("Not your turn!")
10        
11        # Place the piece on the board
12        game.get_board().place_symbol(row, col, player.get_symbol())
13        
14        # Check for a winner or a draw
15        if game.check_winner(player):
16            game.set_winner(player)
17            game.set_status(GameStatus.WINNER_X if player.get_symbol() == Symbol.X else GameStatus.WINNER_O)
18            game.set_state(WinnerState())
19        elif game.get_board().is_full():
20            game.set_status(GameStatus.DRAW)
21            game.set_state(DrawState())
22        else:
23            # If the game is still in progress, switch players
24            game.switch_player()
25
26
27class DrawState(GameState):
28    def handle_move(self, game, player: Player, row: int, col: int):
29        raise InvalidMoveException("Game is already over. It was a draw.")
30
31
32class WinnerState(GameState):
33    def handle_move(self, game, player: Player, row: int, col: int):
34        raise InvalidMoveException(f"Game is already over. {game.get_winner().get_name()} has won.")

1class Game(GameSubject):
2    def __init__(self, player1: Player, player2: Player):
3        super().__init__()
4        self.board = Board(3)
5        self.player1 = player1
6        self.player2 = player2
7        self.current_player = player1  # Player 1 starts
8        self.winner = None
9        self.status = GameStatus.IN_PROGRESS
10        self.state = InProgressState()
11        self.winning_strategies = [
12            RowWinningStrategy(),
13            ColumnWinningStrategy(),
14            DiagonalWinningStrategy()
15        ]
16    
17    def make_move(self, player: Player, row: int, col: int):
18        self.state.handle_move(self, player, row, col)
19    
20    def check_winner(self, player: Player) -> bool:
21        for strategy in self.winning_strategies:
22            if strategy.check_winner(self.board, player):
23                return True
24        return False
25    
26    def switch_player(self):
27        self.current_player = self.player2 if self.current_player == self.player1 else self.player1
28    
29    def get_board(self):
30        return self.board
31    
32    def get_current_player(self):
33        return self.current_player
34    
35    def get_winner(self):
36        return self.winner
37    
38    def set_winner(self, winner: Player):
39        self.winner = winner
40    
41    def get_status(self):
42        return self.status
43    
44    def set_state(self, state: GameState):
45        self.state = state
46    
47    def set_status(self, status: GameStatus):
48        self.status = status
49        # Notify observers when the status changes to a finished state
50        if status != GameStatus.IN_PROGRESS:
51            self.notify_observers()

1class TicTacToeSystem:
2    _instance = None
3    _lock = threading.Lock()
4    
5    def __new__(cls):
6        if cls._instance is None:
7            with cls._lock:
8                if cls._instance is None:
9                    cls._instance = super().__new__(cls)
10        return cls._instance
11    
12    def __init__(self):
13        if not hasattr(self, 'initialized'):
14            self.game = None
15            self.scoreboard = Scoreboard()  # The system now manages a scoreboard
16            self.initialized = True
17    
18    @classmethod
19    def get_instance(cls):
20        return cls()
21    
22    def create_game(self, player1: Player, player2: Player):
23        self.game = Game(player1, player2)
24        # Register the scoreboard as an observer for this new game
25        self.game.add_observer(self.scoreboard)
26        
27        print(f"Game started between {player1.get_name()} (X) and {player2.get_name()} (O).")
28    
29    def make_move(self, player: Player, row: int, col: int):
30        if self.game is None:
31            print("No game in progress. Please create a game first.")
32            return
33        
34        try:
35            print(f"{player.get_name()} plays at ({row}, {col})")
36            self.game.make_move(player, row, col)
37            self.print_board()
38            print(f"Game Status: {self.game.get_status().value}")
39            if self.game.get_winner() is not None:
40                print(f"Winner: {self.game.get_winner().get_name()}")
41        except InvalidMoveException as e:
42            print(f"Error: {e}")
43    
44    def print_board(self):
45        self.game.get_board().print_board()
46    
47    def print_score_board(self):
48        self.scoreboard.print_scores()

1class TicTacToeDemo:
2    @staticmethod
3    def main():
4        system = TicTacToeSystem.get_instance()
5        
6        alice = Player("Alice", Symbol.X)
7        bob = Player("Bob", Symbol.O)
8        
9        # --- GAME 1: Alice wins ---
10        print("--- GAME 1: Alice (X) vs. Bob (O) ---")
11        system.create_game(alice, bob)
12        system.print_board()
13        
14        system.make_move(alice, 0, 0)
15        system.make_move(bob, 1, 0)
16        system.make_move(alice, 0, 1)
17        system.make_move(bob, 1, 1)
18        system.make_move(alice, 0, 2)  # Alice wins, scoreboard is notified
19        print("----------------------------------------\n")
20        
21        # --- GAME 2: Bob wins ---
22        print("--- GAME 2: Alice (X) vs. Bob (O) ---")
23        system.create_game(alice, bob)  # A new game instance
24        system.print_board()
25        
26        system.make_move(alice, 0, 0)
27        system.make_move(bob, 1, 0)
28        system.make_move(alice, 0, 1)
29        system.make_move(bob, 1, 1)
30        system.make_move(alice, 2, 2)
31        system.make_move(bob, 1, 2)  # Bob wins, scoreboard is notified
32        print("----------------------------------------\n")
33        
34        # --- GAME 3: A Draw ---
35        print("--- GAME 3: Alice (X) vs. Bob (O) - Draw ---")
36        system.create_game(alice, bob)
37        system.print_board()
38        
39        system.make_move(alice, 0, 0)
40        system.make_move(bob, 0, 1)
41        system.make_move(alice, 0, 2)
42        system.make_move(bob, 1, 1)
43        system.make_move(alice, 1, 0)
44        system.make_move(bob, 1, 2)
45        system.make_move(alice, 2, 1)
46        system.make_move(bob, 2, 0)
47        system.make_move(alice, 2, 2)  # Draw, scoreboard is not notified of a winner
48        print("----------------------------------------\n")
49        
50        # --- Final Scoreboard ---
51        # We get the scoreboard from the system and print its final state
52        system.print_score_board()
53
54
55if __name__ == "__main__":
56    TicTacToeDemo.main()