import java.util.Arrays;

/*
 * Programma per giocare a tris tra un giocatore umano e un computer.
 *
 * Lo stato attuale della griglia del gioco viene memorizzato in un array bidimensionale di
 * caratteri (che chiamiamo board). Ogni cella dell'array corrisponde ad una posizione nella griglia
 * del gioco. Essa può contenere uno spazio ' ', per indicare che la cella è vuota, oppure una X o
 * una O (i simboli dei due giocatori che si sfidano) per indicare la presenza di un gettone di quel
 * giocatore. La dimensione del campo da gioco può variare da una partita all'altra.
 */
public class Tris {

    /**
     * Dimensione della griglia del gioco del tris.
     */
    public static final int BOARD_DIMENSION = 3;

    /**
     * Visualizza il contenuto dell'array "board" sullo schermo in un formato quanto più possibile
     * simile ad una griglia del gioco del Tris.
     */
    public static void showBoard(char[][] board) {
        for (int i = 0; i < board.length; i++) {
            if (i > 0) {
                for (int j = 0; j < board[i].length; j++) {
                    if (j > 0)
                        System.out.print("-");
                    System.out.print("-");
                }
                System.out.println();
            }
            for (int j = 0; j < board[i].length; j++) {
                if (j > 0)
                    System.out.print("|");
                System.out.print(board[i][j]);
            }
            System.out.println();
        }
    }

    /**
     * Crea e restituisce un array rappresentante una griglia del gioco del tris completamente vuota
     * (ovvero tutti gli elementi dell'array devono contenere uno spazio).
     */
    public static char[][] createEmptyBoard() {
        char[][] board = new char[BOARD_DIMENSION][BOARD_DIMENSION];
        for (char[] riga : board) {
            Arrays.fill(riga, ' ');
        }
        return board;
    }

    /**
     * Il computer sceglie automaticamente una mossa valida per il giocatore "player" e la esegue,
     * modificando di conseguenza la griglia rappresentata da "board". Attualmente la scelta è
     * banale: la prima posizione libera.
     */
    public static void moveComputer(char[][] board, char player) {
        for (int i = 0; i < board.length; i++)
            for (int j = 0; j < board[i].length; j++)
                if (board[i][j] == ' ') {
                    board[i][j] = player;
                    return;
                }
    }

    /**
     * Se possibile, la griglia rappresentata da "board" viene aggiornata inserendo il segno del
     * giocatore "player" nella riga "i" colonna "j", e il metodo restituisce true. Se la mossa non
     * è valida, "board" non viene modificata e il metodo restituisce false.
     */
    public static boolean movePlayer(char[][] board, int i, int j, char player) {
        if (i < 0 || j < 0 || i > board.length || j > board[i].length || board[i][j] != ' ')
            return false;
        board[i][j] = player;
        return true;
    }

    /**
     * Considera la cella in riga "r" e colonna "c" della griglia rappresentata in "board". Se da
     * quella cella parte una sequenza di mosse che rende vincente il giocatore g, allora
     * restituisce g. In caso contrario, restituisce uno spazio.
     */
    public static char winnerFrom(char[][] board, int r, int c) {
        char player = board[r][c];
        if (c <= board[0].length - 3 && board[r][c + 1] == player && board[r][c + 2] == player)
            return player;
        if (r <= board.length - 3 && board[r + 1][c] == player && board[r + 2][c] == player)
            return player;
        if (r <= board.length - 3 && c <= board[0].length - 3 && board[r + 1][c + 1] == player
                && board[r + 2][c + 2] == player)
            return player;
        if (r <= board.length - 3 && c >= 2 && board[r + 1][c - 1] == player
                && board[r + 2][c - 2] == player)
            return player;
        return ' ';
    }

    /**
     * Restituisce il giocatore che è vincente nella griglia rappresentata da "board". Se non c'è
     * nessun giocatore vincente, restituisce spazio. Se più di un giocatore è vincente, restituisce
     * uno qualunque tra 'X' ed 'O'.
     */
    public static char winner(char[][] board) {
        for (int i = 0; i < board.length; i++)
            for (int j = 0; j < board[i].length; j++) {
                var winner = winnerFrom(board, i, j);
                if (winner != ' ')
                    return winner;
            }
        return ' ';
    }

    /**
     * Dato in input il simbolo del giocatore corrente, restituisce il simbolo del prossimo
     * giocatore. In sostanza, se "player" è 'X' restituisce 'O', se "player" è 'O' restituisce 'X'.
     */
    public static char nextPlayer(char player) {
        if (player == 'X')
            return 'O';
        else
            return 'X';
    }

    /**
     * Programma principale del gioco del Tris.
     */
    public static void main(String[] args) {
        // TODO
    }
}