import java.util.Scanner;

/**
 * Programma per giocare a Forza 4 tra due giocatori umani.
 *
 * 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 Forza4 {

    /**
     * Visualizza il contenuto dell'array "board" sullo schermo in un formato quanto più possibile
     * simile ad una griglia di gioco di Forza 4.
     */
    public static void showBoard(char[][] board) {
        // TODO
    }

    /**
     * Crea un array rappresentante una griglia di gioco con "numRows" righe e "numCols" colonne,
     * completamente vuota (ovvero tutti gli elementi dell'array devono contenere uno spazio).
     */
    public static char[][] createEmptyBoard(int numRows, int numCols) {
        // TODO
        return new char[0][0];
    }

    /**
     * Controlla che, data la griglia di gioco rappresentana dall'array "board", la mossa di mettere
     * un gettone nella colonna "col" sia valida. Più precisamente, la mossa è valida se "col" è
     * compreso tra 0 e il numero di colonna massimo possibile, e se nella colonna "col" c'è spazio
     * per inserire un nuovo gettone.
     */
    public static boolean checkMove(char[][] board, int col) {
        // TODO
        return false;
    }

    /**
     * Modifica l'array "board", con il nuovo stato del gioco che consegue all'inserimento di un
     * gettone del giocatore "player" nella colonna "col".
     */
    public static void move(char[][] board, int col, char player) {
        // TODO
    }

    /**
     * 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) {
        // TODO
        return ' ';
    }

    /**
     * Considera la cella in riga "r" e colonna "c" della griglia rappresentata in "board". Se da
     * quella cella parte una sequenza di gettoni 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 - 4 && board[r][c + 1] == player && board[r][c + 2] == player
                && board[r][c + 3] == player)
            return player;
        if (r <= board.length - 4 && board[r + 1][c] == player && board[r + 2][c] == player
                && board[r + 3][c] == player)
            return player;
        if (r <= board.length - 4 && c <= board[0].length - 4 && board[r + 1][c + 1] == player
                && board[r + 2][c + 2] == player && board[r + 3][c + 3] == player)
            return player;
        if (r <= board.length - 4 && c >= 3 && board[r + 1][c - 1] == player
                && board[r + 2][c - 2] == player && board[r + 3][c - 3] == 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[0].length; j++) {
                var winner = winnerFrom(board, i, j);
                if (winner != ' ')
                    return winner;
            }
        return ' ';
    }

    /**
     * Programma principale del gioco di Forza 4.
     */
    public static void main(String[] args) {
        Scanner kbd = new Scanner(System.in);
        // Chiede ai giocatori la dimensione del campo da gioco.
        System.out.print("Inserisci numero di righe e colonne della matrice di gioco: ");
        var n = kbd.nextInt();
        var m = kbd.nextInt();
        // Usiamo la variabile "board" per memorizzare la situazione attuale del campo da gioco.
        // Inizialmente creiamo un campo da gioco completamente vuoto usando il metodo
        // "createEmptyBoard".
        var board = createEmptyBoard(n, m);
        // Usiamo la variabile "player" per memorizzare il simbolo del giocatore che deve fare la
        // prossima mossa. Si inizia con il giocatore 'X'.
        var player = 'X';
        // Usiamo la variabile "winner" per memorizzare il simbolo del giocatore che ha vinto.
        // Inizialmente contiene uno spazio perché non ha vinto nessuno.
        var winner = ' ';
        // Usiamo la variabile "moves" per contare il numero di mosse effettuare
        var moves = 0;
        // Continua finché non c'è un vincitore oppure è stato riempito tutto il campo da gioco.
        while (winner == ' ' && moves < n * m) {
            // Visualizza il campo da gioco attuale.
            showBoard(board);
            // Chiede la mossa al giocatore corrente.
            System.out.print("Giocatore " + player + ", scrivi la tua mossa: ");
            var choice = kbd.nextInt() - 1;
            // Controlla se la mossa è valida.
            if (checkMove(board, choice)) {
                // Se la mossa è valida, la esegue.
                move(board, choice, player);
                // Aggiorna la variabile "winner", nel caso ci sia un vincitore.
                winner = winner(board);
                // Aggiorna il giocatore corrente.
                player = nextPlayer(player);
                // Incrementa il numero di mosse effettuate.
                moves += 1;
            } else {
                // Se la mossa non è valida, visualizza un messaggio di errore.
                System.out.println("MOSSA NON VALIDA, RIPROVA");
            }
        }
        // Mostra l'ultima volta il campo da gioco e comunica il risultato della partita.
        showBoard(board);
        if (winner != ' ')
            System.out.println("HA VINTO IL GIOCATORE " + winner);
        else
            System.out.println("PAREGGIO");
        kbd.close();
    }
}