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

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

/********************************************************************
 * BlackjackUI
 *
 * Member Variables: 
 *    ImageIcon[] playerCard - images of player's hand
 *    JLabel[] playerLabel   - playerLabel[0] contains the player's score
 *    JButton cmdDeal        - Deal button
 *    JButton cmdStand       - Stand button
 *    JButton cmdQuit        - Quit button
 *    JLabel instructLabel   - label that contains the instructions
 *    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()     - draw all blank cards
 *    void setCard(int position, Card c) - draw the image of the card
 *
 * 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 visual constants
      private final static String TITLE = "Blackjack";
      private final static int HEIGHT = 400;

      // Button state constants
      private final static boolean IS_DEAL = true;
      private final static boolean IS_HIT = false;
   
      // MEMBER VARIABLES

      // Card images
      private ImageIcon[] playerCard;
      private JLabel[] playerLabel;
      // Buttons 
      private JButton cmdDeal;       // Deal button
      private JButton cmdStand;      // Stand button
      private JButton cmdQuit;       // Quit button
      // Others
      private JLabel instructLabel;  // Instruction 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<=Deck.DECK_SIZE+1; i++)  {
            imgDeck[i] = new ImageIcon("img/"+i+".gif");   
         }                                                 
      
         // Set window properties                                  
         setTitle(TITLE);                                       
         setSize(imgDeck[0].getIconWidth()*BlackjackGame.MAX_CARDS_IN_HAND+50, 
                 HEIGHT); 
         setBackground(Color.green.darker().darker());
      	         
      	 // Get content and set layout of window
         Container content = getContentPane();    
         content.setLayout(new BorderLayout());
      
         // Declare and instantiate different panels
         JPanel playerCardPanel = new JPanel(new GridLayout (1,
                                            BlackjackGame.MAX_CARDS_IN_HAND));
         JPanel middlePanel = new JPanel(new GridLayout(3,1));
         JPanel bottomPanel = new JPanel (new BorderLayout());
         JPanel instructPanel = new JPanel(new FlowLayout());
         JPanel tallyPanel = new JPanel(new FlowLayout());
         JPanel buttonPanel = new JPanel(new GridLayout(1,3));
            
         // 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();
         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 instructions
         instructLabel = new JLabel("Click Deal to Begin.");
         instructLabel.setForeground(Color.white);
         instructPanel.add(instructLabel);
         instructPanel.setBackground(Color.green.darker().darker());
         middlePanel.add(instructPanel);
		
         // Setup buttons
         cmdDeal = new JButton("Deal");
         cmdDeal.addActionListener(this);
         cmdDeal.setBackground(Color.green.darker().darker());
         buttonState = IS_DEAL;
         buttonPanel.add(cmdDeal);
         cmdStand = new JButton("Stand");
         cmdStand.addActionListener(this);
         cmdStand.setBackground(Color.green.darker().darker());
         cmdStand.setEnabled(false);
         buttonPanel.add(cmdStand);
         cmdQuit = new JButton("Quit");
         cmdQuit.addActionListener(this);
         cmdQuit.setBackground(Color.green.darker().darker());
         buttonPanel.add(cmdQuit);
         buttonPanel.setBackground(Color.green.darker().darker());
         middlePanel.setBackground(Color.green.darker().darker());
         middlePanel.add(buttonPanel);
			
         // Setup bottom panel
         bottomPanel.add (middlePanel, BorderLayout.CENTER);
         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
       * and total points in the user interface.
       * Sets the Deal button to Hit and enables the
       * Stand button.
       * Called from: actionPerformed()
       *********************************************/
      private void dealButtonPressed()
      {
         BlackjackGame.setupNewHand();
      	
         // draw all blank cards
         drawBlankCards();
			
      	 // draw player hand in the user interface
         for (int i=0; i<BlackjackGame.getPlayerHand().getNumCards(); i++) {
            setCard (i, BlackjackGame.getPlayerHand().getCard(i));
         }
         playerLabel[0].setText("Player: " + 
                      BlackjackGame.calcPoints(BlackjackGame.getPlayerHand()));

         // 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));
			
         // 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.
       * Calls playerDone()
       * Called from: actionPerformed()
       *********************************************/
      private void standButtonPressed() 
      {
           playerDone();      
      }
   
      /*********************************************
       * playerDone
       *
       * Takes no parameters and returns nothing.
       * Resets instructions and buttons to original
       * state (only Deal and Quit enabled).
       *********************************************/
      private void playerDone()
      {
         instructLabel.setText ("Click Deal to play again.");

         // reset buttons   	
         cmdDeal.setText("Deal");
         buttonState = IS_DEAL;
         cmdStand.setEnabled(false);
      }
	
      /*********************************************
       * drawBlankCards
       *
       * Takes no parameters and returns nothing.
       * Draws a blank card in each card position. 
       *********************************************/
      private void drawBlankCards()
      {
          Card blankCard = new Card (-1, 0);   // blank card

          for (int i=0; i<BlackjackGame.MAX_CARDS_IN_HAND; i++) {
                 setCard (i, blankCard);
          }
      }      
   
      /*********************************************
       * 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)
      {                
         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;            
         }
         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