package netgame.fivecarddraw;

import java.io.IOException;

import netgame.common.*;

/**
 * A PokerHub manages a networked game of Five Card Draw Poker
 * between two players.  Each player is using a PokerWindow
 * as the GUI for the game.  The Hub keeps track of the full state
 * of the game, and it sends messages of type PokerGameState to
 * each player reflecting what that player needs to know about
 * the game state.  It also sends strings as messages.  These
 * strings are simply displayed by the PokerWindow to the
 * user.  Finally, when a game of poker ends because one player
 * "calls" the other, an array-of-PokerCard is sent to each player
 * with the contents of the opposing player's hand.  
 * <p>The first message is sent when the second player connects.  At 
 * that time, the Hub sends the initial PokerGameState to both players.
 * In this first message, the player's hand's are null.  They will
 * be set after the first player clicks "DEAL" to start the first game.
 * <p>As for incoming messages from the clients, the Hub recognizes:
 * (1) the string "deal" is sent when a player clicks "DEAL" to start
 * a game; (2) the string "fold" is sent when a player folds;
 * (3) a value of type Integer represents an amount that the player
 * wants to bet (the amount can be zero if the player sees or calls);
 * and (4) a value of type int[] when a player discards cards (the
 * values in the array are indices in the player's hand that the
 * player wants to discard).
 * <p>Programming note:  When a player's hand is sent as part of
 * a message, it is a cloned copy of the array that is sent.  This
 * is make sure that no object is sent more than once, after having
 * been changed in the meantime.  Because of this, it is unnecessary
 * to reset the ObjectOutputStreams that are used to send messages.
 * (See the reset() and setAutoreset() methods in the Hub class for
 * information about this issue.)
 */
public class PokerHub extends Hub {
    
    private PokerDeck deck = new PokerDeck();  // The deck of 52 playing cards.
    
    // The next five variables are possible values of the status variable.
    
    private final static int WAITING_FOR_DEAL = 0;        // Hub is waiting for a player to click "DEAL".
    private final static int WAITING_FOR_FIRST_BET = 1;   // Hub is waiting for the first bet (or fold) in a betting round.
    private final static int WAITING_FOR_BET_OR_SEE = 2;  // Hub is waiting for a later bet (or call/see/fold).
    private final static int WAITING_FOR_FIRST_DRAW = 3;  // Hub is waiting for the first player to discard cards.
    private final static int WAITING_FOR_SECOND_DRAW = 4; // Hub is waiting for the second player to discard cards.
    
    private int status; // The basic game status, one of the preceding 6 values, telling what message the hub is expecting.
    
    private int currentPlayer;  // The ID number (1 or 2) player who is to send the next message.
                                // Note that the ID number of the opposing player is always 3-currentPlayer.

    private int dealer; // The ID number (1 or 2) of the "dealer" for this game.  Player #1 deals the first hand,
                        // then the deal alternates between players.  The dealer's opponent is the first to bet
                        // in each betting round.
    
    private boolean firstBettingRound;  // If status is  
    
    private int amountNeededToSee;  // If status is WAITING_FOR_BET_OR_CALL, this is the amount
                                    // of money that is needed to "SEE" the previous bet.  It is
                                    // the minimum possible bet amount.  If the actual bet is equal
                                    // to this amount, then the current round of betting ends.
    
    private boolean previousGameTied = false;  // This is set to true at the end of a game in the
                                               // unlikely case that two player's hands are of exactly
                                               // the same value.  In that case, the "pot" stays on
                                               // the table for the next game.

    private PokerCard[][] hand = new PokerCard[2][5];  // The two player's hands.  hand[0] belongs
                                                       // to Player #1; hand[1] belongs to Player #2.
    
    private int[] money = new int[2];  // money[0] is the amount of money that Player #1 has left;
                                       // money[1] is the amount of money that Player #2 has left.
                                       // These values are initialized to 1000 at the start.  They
                                       // can become negative, and nothing is done about it if they do.
     
    private int pot;  // The total amount of money that has been bet in the current game (or in the
                      // game that has just finished.
    

    /**
     * Creates a PokerHub listening on a specified port.
     */
    public PokerHub(int port) throws IOException {
        super(port);
    }
    

    /**
     * When the second player connects, this method starts the game by
     * sending the initial game state to the two players.  At this time,
     * the players' hands are null.  The hands will be set when the
     * first hand is dealt.  This method also shuts down the Hub's 
     * ServerSocket so that no further players can connect.
     */
    protected void playerConnected(int playerID) {
        if (playerID == 2) {
            shutdownServerSocket();
            dealer = 1;
            currentPlayer = 1;
            money[0] = 1000;
            money[1] = 1000;
            sendToOne(1, new PokerGameState(null,PokerGameState.DEAL,1000,1000,0));
            sendToOne(2, new PokerGameState(null,PokerGameState.WAIT_FOR_DEAL,1000,1000,0));
            sendToAll("Ready to start the first game!");
        }
    }

    
    /**
     * If a player disconnects, the game ends.  This method shuts down
     * the Hub, which will send a signal to the remaining connected player,
     * if any, to let them know that their opponent has left the game.
     * The client will respond by terminating that player's program.
     */
    protected void playerDisconnected(int playerID) {
        shutDownHub();
    }


    /**
     * This is the method that responds to messages received from the
     * clients.  It handles all of the action of the game.  When a message
     * is received, this method will make any changes to the state of
     * the game that are triggered by the message.  It will then send
     * information about the new state to each player, and it will
     * generally send a string to each client as a message to be
     * displayed to that player.
     */
    protected void messageReceived(int playerID, Object message) {
        if (playerID != currentPlayer) {
               // This should not happen, assuming there are no bugs and the
               // connected clients are in fact PokerClients.  This test and
               // other tests in this method are included mostly for debugging.
            System.out.println("Error: message received from the wrong player.");
            return;
        }
        if (message.equals("deal")) {
            if (status != WAITING_FOR_DEAL) {
                System.out.println("Error: DEAL message received at incorrect time.");
                return;
            }
            // Suffle the deck, deal the cards, add a $5 ante from each player to the pot, and start the game.
            deck.shuffle();
            for (int i = 0; i < 5; i++) {
                hand[0][i] = deck.dealCard();
                hand[1][i] = deck.dealCard();
            }
            money[0] -= 5;
            money[1] -= 5;
            if (previousGameTied) {
                pot += 10;
                previousGameTied = false;
            }
            else
                pot = 10;
            currentPlayer = 3 - dealer;     // Dealer's opponent will bet first.
            status = WAITING_FOR_FIRST_BET; // Start the first round of betting.
            firstBettingRound = true;
            sendState(PokerGameState.BET_OR_FOLD, PokerGameState.WAIT_FOR_BET);
            sendToAll("Cards have been dealt.  $5 ante.");
        }
        else if (message.equals("fold")) {
            if (status != WAITING_FOR_FIRST_BET && status != WAITING_FOR_BET_OR_SEE) {
                System.out.println("Error: FOLD message received at incorrect time.");
                return;
            }
            // The game ends because the currentPlayer folded.  The opponent of the player who folded wins.
            gameOver(3-currentPlayer, "Your opponent has folded.","You folded");
        }
        else if (message instanceof Integer) {  // A bet.
            if (status != WAITING_FOR_FIRST_BET && status != WAITING_FOR_BET_OR_SEE) {
                System.out.println("Error: BET message received at incorrect time.");
                return;
            }
            // Apply a bet.  A bet of 0 indicates that the first player to bet has "PASSed".
            int bet = (Integer)message;
            if (bet < 0 || (status == WAITING_FOR_BET_OR_SEE && bet < amountNeededToSee)) {
                System.out.println("Error: Illegal bet amount received.");
                return;
            }
            // Move the bet amount from the player's money to the pot.  (No change if bet is 0.)
            pot += bet;
            money[currentPlayer-1] -= bet;
            // Update the state and inform the players.
            if (status == WAITING_FOR_FIRST_BET) {
                   // This was the first bet in a betting round.  Betting continues.  The other
                   // player must match the amount of the bet (or fold).
                sendToOne(currentPlayer, "You bet $" + bet);
                sendToOne(3-currentPlayer, "Your opponent bets $" + bet);
                currentPlayer = 3-currentPlayer;
                amountNeededToSee = bet;
                status = WAITING_FOR_BET_OR_SEE;
                if (firstBettingRound)
                    sendState(PokerGameState.RAISE_SEE_OR_FOLD_ROUND_1,PokerGameState.WAIT_FOR_BET);
                else
                    sendState(PokerGameState.RAISE_CALL_OR_FOLD_ROUND_2,PokerGameState.WAIT_FOR_BET);
            }
            else if (status == WAITING_FOR_BET_OR_SEE) {
                   // This was not the first bet in a betting round.
                if (bet == amountNeededToSee) {
                       // If the bet is the amount needed to match the opponent's bet, 
                       // then the betting round ends.  (This is a "SEE" or "CALL".)
                    if (firstBettingRound) {
                           // The first betting round has ended; proceed to the discarding of cards.
                        sendToOne(currentPlayer, "You see.  First round of betting ends.");
                        sendToOne(3-currentPlayer, "Your opponents sees.  First round of betting ends.");
                        currentPlayer = 3-dealer; // The same player who bet first, draws first.
                        status = WAITING_FOR_FIRST_DRAW;
                        sendState(PokerGameState.DRAW,PokerGameState.WAIT_FOR_DRAW);
                    }
                    else {
                          // The second betting round has ended; the game ends.
                        checkCardsAtEndOfGame();
                    }
                }
                else {
                       // The player matches the opponent's bet and raises; the betting round ends.
                       // The opposing player must match the amount by which the player's bet
                       // exceeded the minimum that that player had to play to match the previous bet.
                    amountNeededToSee = bet - amountNeededToSee;
                    sendToOne(currentPlayer, "You see the bet and raise by $" + amountNeededToSee);
                    sendToOne(3-currentPlayer, "Your opponent sees your bet and raises by $" + amountNeededToSee);
                    currentPlayer = 3 - currentPlayer;
                    if (firstBettingRound)
                        sendState(PokerGameState.RAISE_SEE_OR_FOLD_ROUND_1,PokerGameState.WAIT_FOR_BET);
                    else
                        sendState(PokerGameState.RAISE_CALL_OR_FOLD_ROUND_2,PokerGameState.WAIT_FOR_BET);
                }
            }
        }
        else if (message instanceof int[]) {  // A list of card indices to be replaced
            if (status != WAITING_FOR_FIRST_DRAW && status != WAITING_FOR_SECOND_DRAW) {
                System.out.println("Error: DISCARD message received at incorrect time");
                return;
            }
            // Replace the cards that the player discarded.
            int[] cardNums = (int[])message;
            PokerCard[] currentPlayerHand = (currentPlayer == 1)? hand[0] : hand[1];
            for (int i = 0; i < cardNums.length; i++) {
                currentPlayerHand[cardNums[i]] = deck.dealCard();
            }
            sendToOne(currentPlayer,"You draw " + cardNums.length + " cards");
            sendToOne(3-currentPlayer,"Your opponent draws " + cardNums.length + " cards");
            if (status == WAITING_FOR_FIRST_DRAW) {
                   // This was the first player to draw; proceed to the opposing player's draw.
                currentPlayer = 3 - currentPlayer;
                status = WAITING_FOR_SECOND_DRAW;
                sendState(PokerGameState.DRAW,PokerGameState.WAIT_FOR_DRAW);
            }
            else {
                   // This was the second player's draw; proceed to the second round of betting.
                currentPlayer = 3-dealer;
                status = WAITING_FOR_FIRST_BET;
                firstBettingRound = false;
                sendState(PokerGameState.BET_OR_FOLD, PokerGameState.WAIT_FOR_BET);
            }
        }
    }
    
    
    // --- The remaining methods are called by messageReceived() to do some of its processing ---
    
    
    /**
     * When the game ends because one player has "called" the other, this method
     * will be called to compare the players' hands and determine the winner.
     * Objects of type PokerRank are used to assign rankings to each hand.
     */
    private void checkCardsAtEndOfGame() {
        PokerRank[] rank = new PokerRank[2];
        for (int i = 0; i < 2; i++) {
            rank[i] = new PokerRank();
            for (PokerCard c : hand[i])
                rank[i].add(c);
        }
        int winner; // 0 if Player #1 wins; 1 if Player #2 wins; -1 if they are tied.
        if (rank[0].getRank() > rank[1].getRank())
            winner = 0;  // Player #1's hand has higher rank.
        else if (rank[0].getRank() < rank[1].getRank())
            winner = 1;  // Player #2's hand has higher rank.
        else
            winner = -1; // Players' hands have the same rank.
        sendToOne(1,hand[1].clone());  // Send opponent's hand to Player #1.
        sendToOne(2,hand[0].clone());  // Send opponent's hand to Player #2.
        if (winner != -1) {  // One of the players won.
            gameOver(winner+1,rank[winner] + " beats " + rank[1-winner],
                    rank[winner] + " beats " + rank[1-winner]);
        }
        else {  // Game was a tie.
            sendToAll("The result is a tie.  The pot stays on the table.");
            previousGameTied = true;
            dealer = 3-dealer;  // Dealer's opponent becomes dealer for next game.
            currentPlayer = dealer;
            status = WAITING_FOR_DEAL;
            sendState(PokerGameState.DEAL,PokerGameState.WAIT_FOR_DEAL);
        }
    }
    
    
    /**
     * This method is called when the game ends and there is a winner.  It gives the pot to the
     * winner, sends each player a message about the outcome of the game, changes the state
     * to get ready for the next game, and sends a state message to each player.
     * @param winner  The ID number -- 1 or 2 -- of the player who won the game.
     * @param winnerMessage A message to be sent to the winning player.
     * @param loserMessage A message to be sent to the losing player.
     */
    private void gameOver(int winner, String winnerMessage, String loserMessage) {
        sendToOne(winner, "You win. " + winnerMessage);
        sendToOne(3-winner, "You lose.  " + loserMessage); // "3-winner" is the ID number of the loser.
        money[winner-1] += pot; // The winner takes the pot; pot amount is added to winner's money.
        dealer = 3-dealer;      // Dealer's opponent becomes dealer for the next game.
        currentPlayer = dealer; // The dealer will have to start the next hand by clicking "DEAL".
        status = WAITING_FOR_DEAL;
        sendState(PokerGameState.DEAL,PokerGameState.WAIT_FOR_DEAL);
    }
    
    
    /**
     * This method is used by messageReceived() to send state messages to both
     * players.  
     * @param currentPlayerState  The state of the player who makes the next move.
     *    One of the status values from the PokerGameState class.
     * @param opponentState The state of the opposing player.
     *    One of the status values from the PokerGameState class.
     */
    private void sendState(int currentPlayerState, int opponentState) {
        int player1State, player2State;  // The states for Player #1 and #2.
        if (currentPlayer == 1) {
            player1State = currentPlayerState;
            player2State = opponentState;
        }
        else {
            player2State = currentPlayerState;
            player1State = opponentState;
        }
        if (status == WAITING_FOR_BET_OR_SEE) {  // Send a state message including an amount needed to see.
            sendToOne(1, new PokerGameState(hand[0].clone(),player1State,money[0],money[1],pot,amountNeededToSee));
            sendToOne(2, new PokerGameState(hand[1].clone(),player2State,money[1],money[0],pot,amountNeededToSee));
        }
        else { // Send a state message without an amount needed to see.
            sendToOne(1, new PokerGameState(hand[0].clone(),player1State,money[0],money[1],pot));
            sendToOne(2, new PokerGameState(hand[1].clone(),player2State,money[1],money[0],pot));
        }
    }
    
    
}