// Programmers: Michele Weigle and Peter VanLund
// Assignment: Program 6

   import java.awt.*;
   import java.awt.event.*;
   import javax.swing.*;

/********************************************************************
 * BlackjackUI
 *
 * Member Variables: 
 *    ImageIcon[] playerCard - images of player's hand
 *    ImageIcon[] dealerCard - images of dealer's hand
 *    JLabel[] playerLabel   - playerLabel[0] contains the player's score
 *    JLabel[] dealerLabel   - dealerLabel[0] contains the dealer's score
 *    JButton cmdDeal        - Deal button
 *    JButton cmdStand       - Stand button
 *    JButton cmdQuit        - Quit button
 *    JLabel instructLabel   - label that contains the instructions
 *    JLabel tallyLabel      - label that contains the wins/losses/ties
 *    boolean buttonState    - state of the Deal/Hit button
 *    ImageIcon[] imgDeck    - images for the entire deck of cards
 *
 * Private Methods: 
 *    void dealButtonPressed()  - called when the Deal button is pressed
 *    void hitButtonPressed()   - called when the Hit button is pressed
 *    void standButtonPressed() - called when the Stand button is pressed
 *    void playerDone()         - finish player's turn
 *    void drawBlankCards(boolean dealer) - draw all blank cards for 
 *                                dealer/player
 *    void setCard(int position, Card c, boolean dealer) - draw the image 
 *                                of the card in the appropriate hand
 *
 * Public Methods: 
 *    BlackjackUI()  -  constructor that sets up the user interface
 *    void actionPerformed(ActionEvent e) - handles button press
 *
 * Protected Methods:
 *    void processWindowEvent(WindowEvent e) - handles when app closed
 *******************************************************************/ 
   public class BlackjackUI extends JFrame implements ActionListener 
   {
      // Window visuals constants
      private final static String TITLE = "Blackjack";
      private final static int HEIGHT = 600;
   
      // Button state constants
      private final static boolean IS_DEAL = true;
      private final static boolean IS_HIT = false;
   	
      private final static boolean PLAYER = false;
      private final static boolean DEALER = true;
   
      // MEMBER VARIABLES
   
      // Card images
      private ImageIcon[] playerCard;
      private ImageIcon[] dealerCard;
      private JLabel[] playerLabel;
      private JLabel[] dealerLabel;
      // Buttons 
      private JButton cmdDeal;       // Deal button
      private JButton cmdStand;      // Stand button
      private JButton cmdQuit;       // Quit button	
      // Others
      private JLabel instructLabel;  // Instruction label
      private JLabel tallyLabel;     // Tally label
      private boolean buttonState;   // State of Deal/Hit button
      private ImageIcon[] imgDeck;   // Images of deck of cards
   	
      /*********************************************
       * constructor
       *
       * Sets up the user interface -- draws buttons
       * cards, labels.
       *********************************************/
      public BlackjackUI() 
      {
      	 // Instantiate deck array and hand
         imgDeck = new ImageIcon[Deck.DECK_SIZE+2];
      
      	 // Instantiate each card in deck image in img folder
         for(int i=0; i<imgDeck.length; i++)  { 
            imgDeck[i] = new ImageIcon("img/"+i+".gif");   
         }                                                 
      
         // Set window properties                                  
         setTitle(TITLE);                                       
         setSize(imgDeck[0].getIconWidth()*BlackjackGame.MAX_CARDS_IN_HAND+50, 
                 HEIGHT); 
      	         
      	 // Get content and set layout of window
         Container content = getContentPane();    
         content.setLayout(new BorderLayout());
      
         // Declare and instantiate different panels
         JPanel dealerCardPanel = new JPanel(new GridLayout (1, 
                                            BlackjackGame.MAX_CARDS_IN_HAND));
         JPanel playerCardPanel = new JPanel(new GridLayout (1, 
                                            BlackjackGame.MAX_CARDS_IN_HAND));
         JPanel bottomPanel = new JPanel(new GridLayout(3,1));
         JPanel buttonPanel = new JPanel(new GridLayout(1,3));
      
         // Setup dealer's hand
         dealerCard = new ImageIcon[BlackjackGame.MAX_CARDS_IN_HAND];
         for (int i=0; i<dealerCard.length; i++) {
            dealerCard[i] = new ImageIcon();
         }
         dealerLabel = new JLabel[BlackjackGame.MAX_CARDS_IN_HAND];
         for (int i=0; i<dealerLabel.length; i++) {
            dealerLabel[i] = new JLabel (" ", dealerCard[i], 
                SwingConstants.LEFT);
            dealerLabel[i].setHorizontalTextPosition(SwingConstants.CENTER);
            dealerLabel[i].setVerticalTextPosition(SwingConstants.TOP);
            dealerLabel[i].setForeground(Color.yellow);
         }
         drawBlankCards(DEALER);
         dealerLabel[0].setText ("Dealer:");
         for (int i=0; i<dealerLabel.length; i++) {
            dealerCardPanel.add(dealerLabel[i]);
         }
         dealerCardPanel.setBackground(Color.green.darker().darker());
         content.add(dealerCardPanel, BorderLayout.NORTH);
            
         // Setup player's hand
         playerCard = new ImageIcon[BlackjackGame.MAX_CARDS_IN_HAND];
         for (int i=0; i<playerCard.length; i++) {
            playerCard[i] = new ImageIcon();
         }
         playerLabel = new JLabel[BlackjackGame.MAX_CARDS_IN_HAND];
         for (int i=0; i<playerLabel.length; i++) {
            playerLabel[i] = new JLabel (" ", playerCard[i], 
                SwingConstants.LEFT);
            playerLabel[i].setHorizontalTextPosition(SwingConstants.CENTER);
            playerLabel[i].setVerticalTextPosition(SwingConstants.TOP);
            playerLabel[i].setForeground(Color.yellow);
         }
         drawBlankCards(PLAYER);
         playerLabel[0].setText ("Player:");
         for (int i=0; i<playerLabel.length; i++) {
            playerCardPanel.add(playerLabel[i]);
         }
         playerCardPanel.setBackground(Color.green.darker().darker());
         content.add(playerCardPanel, BorderLayout.CENTER);
      	      
         // Setup tally 
         tallyLabel = new JLabel ("Wins: 0  Losses: 0  Ties: 0", 
                                  SwingConstants.CENTER);
         tallyLabel.setForeground(Color.cyan);
         bottomPanel.add(tallyLabel);
      			
         // Setup instructions
         instructLabel = new JLabel("Click Deal to Begin.", 
                                    SwingConstants.CENTER);
         instructLabel.setForeground(Color.white);
         bottomPanel.add(instructLabel);
      
         // Setup buttons
         cmdDeal = new JButton("Deal");
         cmdDeal.addActionListener(this);
         buttonState = IS_DEAL;
         buttonPanel.add(cmdDeal);
         cmdStand = new JButton("Stand");
         cmdStand.addActionListener(this);
         cmdStand.setEnabled(false);
         buttonPanel.add(cmdStand);
         cmdQuit = new JButton("Quit");
         cmdQuit.addActionListener(this);
         buttonPanel.add(cmdQuit);
         buttonPanel.setBackground(Color.green.darker().darker());
         bottomPanel.add(buttonPanel);

         // Setup bottom panel
         bottomPanel.setBackground(Color.green.darker().darker());
         content.add(bottomPanel, BorderLayout.SOUTH);
      
         setVisible(true);
      
      } // end of BlackjackUI constructor
   
      /*********************************************
       * dealButtonPressed
       *
       * Takes no parameters and returns nothing.
       * Sets up a new hand.  Draws the player's hand,
       * dealer's hand, total points for player, and
       * known points for dealer in the user interface.
       * Sets the Deal button to Hit and enables the
       * Stand button.
       * Called from: actionPerformed()
       *********************************************/
      private void dealButtonPressed()
      {
         // create temporary face down card for use later
         Card faceDownCard = new Card (-1, -1);
      	
         // setup a new hand
         BlackjackGame.setupNewHand();
      	
         // draw all blank cards
         drawBlankCards(DEALER);
         drawBlankCards(PLAYER);
      	
      	 // draw player hand in the user interface
         for (int i=0; i<BlackjackGame.getPlayerHand().getNumCards(); i++) {
            setCard (i, BlackjackGame.getPlayerHand().getCard(i), PLAYER);
         }
         playerLabel[0].setText("Player: " + 
                BlackjackGame.calcPoints(BlackjackGame.getPlayerHand()));
      
      	 // draw dealer hand (2nd card face down) in user interface
         setCard (0, BlackjackGame.getDealerHand().getCard(0), DEALER);
         setCard (1, faceDownCard, DEALER);
         // show only points for 1st dealer card
         dealerLabel[0].setText("Dealer: " +
           BlackjackGame.calcPoints(BlackjackGame.getDealerHand().getCard(0)) +
                                " known");
              
         // change Deal button to Hit button      
         cmdDeal.setText("Hit");
         buttonState = IS_HIT; 
      	
         // enable Stand button
         cmdStand.setEnabled(true);
      	
         // update instructions 
         instructLabel.setText ("Click Hit to add another card." + 
                                "  Click Stand when done.");
      	
         // can the player add any more cards?
         if (! BlackjackGame.playerCanHit()) {
            playerDone();
         }
      
      } // end of dealButtonPressed method
     
      /*********************************************
       * hitButtonPressed
       *
       * Takes no parameters and returns nothing.
       * Deals a new card to the player and updates
       * the player's hand and total points.
       * Called from: actionPerformed()
       *********************************************/
      private void hitButtonPressed()
      {
      	 // deal new card to player
         BlackjackGame.addPlayerCard();
      	
      	 // draw card in user interface
         int ind = BlackjackGame.getPlayerHand().getNumCards()-1;
         setCard (ind, BlackjackGame.getPlayerHand().getCard(ind), PLAYER);
      	
         // update points               
         playerLabel[0].setText("Player: " + 
                BlackjackGame.calcPoints(BlackjackGame.getPlayerHand()));
      
         // can the player add any more cards?
         if (! BlackjackGame.playerCanHit()) {
            playerDone();
         }
      } // end of hitButtonPressed method
   
      /*********************************************
       * standButtonPressed
       *
       * Takes no parameters and returns nothing.
       * Finishes out the dealer's hand.
       * Calls playerDone()
       * Called from: actionPerformed()
       *********************************************/
      private void standButtonPressed() 
      {
      	 // deal new cards to dealer
         BlackjackGame.addDealerCards();     
      	
         playerDone();      
      }
   
      /*********************************************
       * playerDone
       *
       * Takes no parameters and returns nothing.
       * Reveals the dealer's hand and points, decides
       * winner, updates tally, and resets instructions 
       * and buttons to original state (only Deal 
       * and Quit enabled).
       *********************************************/
      private void playerDone()
      {
         // draw all dealer cards in user interface
         for (int i=0; i<BlackjackGame.getDealerHand().getNumCards(); i++) {
            setCard (i, BlackjackGame.getDealerHand().getCard(i), DEALER);
         }            
         dealerLabel[0].setText ("Dealer: " +
            BlackjackGame.calcPoints(BlackjackGame.getDealerHand()));
      	
         // decide winner
         int winner = BlackjackGame.decideWinner();    
         if (winner == BlackjackGame.DEALER) {
            // dealer wins
            instructLabel.setText ("DEALER WINS!  Click Deal to play again.");
         }
         else if (winner == BlackjackGame.PLAYER) {
            // player wins
            instructLabel.setText ("PLAYER WINS!  Click Deal to play again.");
         }
         else {
            // tie
            instructLabel.setText ("TIE!  Click Deal to play again.");
         }
      	
         // update tally
         tallyLabel.setText ("Wins: " + BlackjackGame.getWins() + 
                             "   Losses: " + BlackjackGame.getLosses() + 
                             "   Ties: " + BlackjackGame.getTies()); 
      	
         // reset buttons   	
         cmdDeal.setText("Deal");
         buttonState = IS_DEAL;
         cmdStand.setEnabled(false);		
      } // end of playerDone method
   
      /*********************************************
       * drawBlankCards
       *
       * Takes as parameter a boolean indicating whether
       * these are the dealer's cards or player's cards
       * Returns nothing.
       * Draws a blank card in each card position. 
       *********************************************/
      private void drawBlankCards(boolean dealer)
      {
         Card blankCard = new Card (-1, 0);   // blank card
      
         for (int i=0; i<BlackjackGame.MAX_CARDS_IN_HAND; i++) {
            setCard (i, blankCard, dealer);
         }
      }      
   
      /*********************************************
       * setCard
       *
       * Takes a position and a Card as parameters.
       * Returns nothing. 
       * Draws the image of the given card in position
       *********************************************/
      private void setCard(int position, Card c, boolean dealer)
      {                
         int index;
      
      	 // Handle all error checking
         if (c == null) {
            System.out.println("setCard error: card is null");        
            return;                                                   
         }                                                           
         else if ((Card.HEARTS>c.getSuit() || c.getSuit()>Card.SPADES) &&
                  (c.getSuit() != -1)) {
            System.out.println("setCard error: suit is out of range");
            return;                                                   
         }                                                           
         else if ((2>c.getFace() || c.getFace()>Card.ACE) &&
                  (c.getFace() != -1)) {
            System.out.println("setCard error: face is out of range");
            return;                                                   
         }                                                           
         else if(0>position || position>BlackjackGame.MAX_CARDS_IN_HAND) {
            System.out.println("setCard error: position is out of range");
            return;                                                       
         }                                                               
      
       	 // Calculate index                                              
         if (c.getSuit() == -1 && c.getFace() == -1) {
            // face down
            index = 0;
         }
         else if (c.getSuit() == 0 && c.getFace() == -1) {
            // blank
            index = Deck.DECK_SIZE+1;
         }
         else {
            index = Deck.CARDS_IN_SUIT*c.getSuit()+c.getFace()-1;            
         }
      
         // Update images
         if (dealer) {
            dealerLabel[position].setIcon(imgDeck[index]);     
         } 
         else {
            playerLabel[position].setIcon(imgDeck[index]);     
         }            
      } // end of setCard method
   
      /*********************************************
       * actionPerformed
       *
       * Takes an event as a parameter and returns nothing
       * Handle button press
       *********************************************/
      public void actionPerformed(ActionEvent e) 
      {                                   
         if (e.getSource() == cmdDeal) {
            if (buttonState == IS_DEAL) {                        
               // Deal                            
               dealButtonPressed();           
            }                              
            else if (buttonState == IS_HIT) {     
               // Hit
               hitButtonPressed();
            }                           
         } 
         else if (e.getSource() == cmdStand) { 
            // Stand
            standButtonPressed();
         }
         else if (e.getSource() == cmdQuit) {
            // Quit
            System.exit(0);
         }
      }  // end of actionPerformed method
   	
      /*********************************************
       * processWindowEvent
       *
       * Takes an event as a parameter and returns nothing
       * Handle when the application close button
       * is pressed
       *********************************************/
      protected void processWindowEvent(WindowEvent e)        
      {                                                   
         super.processWindowEvent(e);                              
         if (e.getID() == WindowEvent.WINDOW_CLOSING) 
            System.exit(0); 
      }                                                          
   	       
   } // end of BlackjackUI class