package netgame.tictactoe;

import java.io.Serializable;



/**
 * This class holds all the necessary information to represent
 * the state of a game of networked TicTacToe.  It includes the 
 * method apply(hub,sender,message), which modifies the state to
 * reflect a message that was received from a player.  The protocol is
 * that two types of messages from client are understood.
 * One is that a TicTacToe client sends the String "newgame" as
 * a message when it wants to start a new game.  The other is that
 * when the user makes a mover into one of the squares on the board,
 * the client sends an array of two ints containing the row
 * and column where the user played.  Note that to keep things
 * simple, each time a game is started, this class decides at random 
 * which of the two players will play 'X' and which will play 'O'.  
 * X always makes the first move.
 */
public class TicTacToeGameState implements Serializable {
   
   //-------------- state variables recording the state of the game -------------------
   
   public boolean playerDisconnected;  // This is true if one of the two players has left the game
                                       // The new state, with this value set to true, is sent to
                                       // the other player as a signal that the game is over.  That
                                       // client will respond by ending the program.

   public char[][] board;  // The contents of the board. Values are ' ', 'X', or 'O'
                           // This variable is null before the first game starts.
   
   public boolean gameInProgress;  // True while a game is being played; 
                                   // false before first game and between games.

   // The next three variables are meant for use while a game is in progress.
   // Note that the ID numbers of the players will always be 1 and 2.
   
   public int playerPlayingX;   // The ID of the player who is playing X.
   public int playerPlayingO;   // The ID of the player who is playing O.
   public int currentPlayer;    // The ID of the player who is to make the next move.
   
   // The next two variables are meant for use between games.
   
   public boolean gameEndedInTie; // Tells whether the game ended in a tie.
   public int winner;   // The name of winner of the game that just ended, if it was not a tie.
   
   
   
   //----------- the method that is called by the Hub to react to messages from the players -----------
   
   /**
    *  Respond to a message that was sent by one of the players to the hub.
    *  Note that illegal messages (of the wrong type or coming at an illegal
    *  time) are simply ignored.  The messages that are understood are
    *  the string "newgame" for starting a new game and an array of two
    *  ints giving the row and column of a move that the user wants to make.
    *  @param sender the ID number of the player who sent the message.
    *  @param message the message that was received from that player.
    */
   public void applyMessage(int sender, Object message) {
      if (gameInProgress && message instanceof int[] && sender == currentPlayer) {
             // The message represents a move by the current player.
         int[] move = (int[])message;
         if (move == null || move.length != 2)
            return;
         int row = move[0];
         int col = move[1];
         if (row < 0 || row > 2 || col < 0 || col > 2 || board[row][col] != ' ')
            return;
         board[row][col] = (currentPlayer == playerPlayingX)? 'X' : 'O'; // Make the move.
         if (winner()) { // CurrentPlayer has won.
            gameInProgress = false;
            winner = currentPlayer;
         }
         else if (tie()) { // The board is full but there is no winner; game ends in a tie.
            gameInProgress = false;
            gameEndedInTie = true;
         }
         else {  // It's the other player's turn now.
            currentPlayer = (currentPlayer == playerPlayingX)? playerPlayingO : playerPlayingX;
         }
      }
      else if (!gameInProgress && message.equals("newgame")) {
         startGame();
      }
   }
   
   /**
    * This package private method is called by the hub when the second player
    * connects.  It's purpose is to start the first game.
    */
   void startFirstGame() {
      startGame();
   }
   
   
   //------------------- Some private utility methods used by the apply() method ---------------
   
   /**
    * Start a game.  Board is initialized to empty.  Players are
    * randomly assigned to play 'X' or 'O'. 
    */
   private void startGame() {
      board = new char[3][3];
      for (int i = 0; i < 3; i++)
         for (int j = 0; j < 3; j++) {
            board[i][j] = ' ';
         }
      int xPlr = (Math.random() < 0.5)? 1 : 2;
      playerPlayingX = xPlr;  // Will be 1 or 2.
      playerPlayingO = 3 - xPlr;  // The other player ( 3 - 1 = 2, and 3 - 2 = 1 )
      currentPlayer = playerPlayingX;
      gameEndedInTie = false;
      winner = -1;
      gameInProgress = true;
   }
   
   /**
    * Check if there is a winner, i.e. three pieces of the same kind in a row.
    */
   private boolean winner() {
      if (board[0][0] != ' ' && 
            (board[0][0] == board[1][1]&& board[1][1] == board[2][2]))
         return true;
      if (board[0][2] != ' ' && 
            (board[0][2] == board[1][1]&& board[1][1] == board[2][0]))
         return true;
      for (int row = 0; row < 3; row++) {
         if (board[row][0] != ' ' &&
               (board[row][0] == board[row][1] && board[row][1] == board[row][2]))
            return true;
      }
      for (int col = 0; col < 3; col++) {
         if (board[0][col] != ' ' &&
               (board[0][col] == board[1][col] && board[1][col] == board[2][col]))
            return true;
      }
      return false;
   }
   
   /**
    * Check if the board is full.  (This is called after the winner method
    * has returned false, so a full board means that the game is a tie.)
    */
   private boolean tie() {
      for (int i = 0; i < 3; i++)
         for (int j = 0; j < 3; j++)
            if (board[i][j] == ' ')
               return false;
      return true;
   }
   
}