/**
 * A Board "paints" the screen background and then uses 2 arrays of 8 pieces each to keep track of moves.
 * 
 * @author Dale Reed 
 * @version October 24, 2008
 */

import java.util.Scanner;

public class Board
{
	// instance variables
    static final int NUMBER_OF_ROWS = 4;
    static final int NUMBER_OF_COLUMNS = 5;
    static final int SQUARE_SIZE = 60;
    /*** OFFSET is the size of extra space around each playing piece */
    static final int OFFSET = 5;         // OFFSET used in boundaries around playing squares
    // set starting values for rectangular playing surface
    static final int STARTING_X_VALUE = 25;	
    static final int STARTING_Y_VALUE = SQUARE_SIZE;
    
    /*** count how many pieces white still has to be placed on the board */
    private int whitePiecesNumber = 8;
    /*** count how many pieces black still has to be placed on the board */
    private int blackPiecesNumber = 8; 
    /*** uses the label to display the number remaining to play for white at top of board */
    private MyRectangle whitePiecesDisplay;		
    /*** uses the label to display the number remaining to play for black at bottom of board */
    private MyRectangle blackPiecesDisplay;		// display remaining pieces for black on screen
    
    /*** array of 8 white playing pieces */
    private Piece[] whitePieces;	
    /*** array of 8 black playing pieces */
    private Piece[] blackPieces;
    
    /***
     * Default constructor that "paints" board background and initializes arrays of pieces.
     * <p>
     * Constructor first allocates memory for each of the 8 pieces in the white and black
     * pieces arrays, setting the color and labels for each of them.  They should all still
     * not be visible, and it is fine for them to all be in the same position (say 0,0),
     * since they are invisible.
     * <br>
     * Next create the large black background rectangle, of width,height size: <br>
     * 	(SQUARE_SIZE+OFFSET)*5 + OFFSET, (SQUARE_SIZE+OFFSET)*4 + OFFSET
     * <p>
     * Following create each of the background squares.  If you know the row and column for 
     * the square, you can use the following formula to place it correctly on the screen: <br>
     * Square theSquare = new Square( x + (SQUARE_SIZE + OFFSET) * columns, y + (SQUARE_SIZE + OFFSET) * row, SQUARE_SIZE, "lightGray", true, "");
	 * <p>
	 * Lastly create and display the rectangles at the top and bottom that display the number
	 * of pieces remaining to play for white and black.
     *
     */
    public Board()
    {
    	// allocate memory for the playing pieces
    	whitePieces = new Piece[ 8];
    	blackPieces = new Piece[ 8];
    	// setup the playing pieces
    	for( int i=0; i<blackPiecesNumber; i++) {
    		// could have just as well used whitePiecesNumber as the loop ending value here
    		// White pieces are labeled from 'A'..'H'
    		whitePieces[ i] = new Piece( 0, 0, SQUARE_SIZE, "white", false, ""+(char)('A'+i), -1);
    		// Black pieces are labeled from 'J'..'Q'
    		blackPieces[ i] = new Piece( 0, 0, SQUARE_SIZE, "gray", false, ""+(char)('J'+i), -1);
    	}
    	      
        // rectangle to display number of pieces remaining for white
        whitePiecesDisplay = new MyRectangle( STARTING_X_VALUE + (SQUARE_SIZE+OFFSET)* 2, 0,
        		                              SQUARE_SIZE, SQUARE_SIZE-10, "white", true, ""); 
        updatePiecesDisplay("white", whitePiecesNumber);
        
        // variables used for drawing
        int x;
        int y;         // first make a large black background rectangle, that will end up being the border
        x = STARTING_X_VALUE;
        y = STARTING_Y_VALUE;
        MyRectangle background = new MyRectangle( x-OFFSET, y-OFFSET,
        		                                 (SQUARE_SIZE+OFFSET)*5 + OFFSET,(SQUARE_SIZE+OFFSET)*4 + OFFSET,
        		                                 "black", true, "");
 
        // Create the playing squares backgrounds.
        // Note that we can reuse the same variable, since we are only using it to "paint" the screen
        // and don't need to modify the playing position backgrounds later
        for( int row=0; row<NUMBER_OF_ROWS; row++) {
        	// for each row...
        	for( int columns=0; columns<NUMBER_OF_COLUMNS; columns++) {
        		// for each column in this row...
		        Square theSquare = new Square( x + (SQUARE_SIZE + OFFSET) * columns, y + (SQUARE_SIZE + OFFSET) * row, 
		        		                       SQUARE_SIZE, "lightGray", true, "");
		        // make a small square in the upper left corner of the bigger one, to display the position number
		        Square smallSquare = new Square( x + (SQUARE_SIZE + OFFSET) * columns, y + (SQUARE_SIZE + OFFSET) * row, 
		        					             SQUARE_SIZE/4, "lightGray", true, ""+( row*NUMBER_OF_COLUMNS + (columns+1)) );
        	}
        }//end for( int rows...
 
        // rectangle to display number of pieces remaining for black
        blackPiecesDisplay = new MyRectangle( STARTING_X_VALUE +(SQUARE_SIZE+OFFSET)* 2, (SQUARE_SIZE+OFFSET)*5,
        		                               SQUARE_SIZE, SQUARE_SIZE, "white", true, ""); 
        updatePiecesDisplay("black", blackPiecesNumber);
    }//end constructor Board()
    
    
    /**
     * return the number of pieces on the board for the indicated color.
     * 
     * @param	theColor	the color of the pieces to be counted
     * @return				the number of pieces on the board for that color
     */
    public int numberOfPiecesFor( String theColor)
    {
    	int theAnswer = 0;
    	
    	// go through the array matching the color, and count how many pieces are on the board
    	for( int i=0; i<whitePieces.length; i++) {
    		// could have just as well used blackPieces.length, as those two arrays are the same size
    		if( theColor.equals("white")) {
    			// color is "white", so counte those pieces
    			if( whitePieces[i].getBoardPosition() != -1) {
    				theAnswer++;
    			}
    		}
    		else {
    			// theColor must be "black", so only count those pieces
    			if( blackPieces[i].getBoardPosition() != -1) {
    				theAnswer++;
    			}
    		}   		
    	}//end for( int i...
    	
    	return theAnswer;
    }//end method numberOfPiecesFor(..)
    
    
    /**
     * return the number of pieces remaining to be placed on the board for the indicated color.
     * 
     * @param 	theColor	color of the player whose pieces are being counted
     * @return				the number of pieces remaining to be placed on board
     */
    public int piecesRemainingToPlayFor( String theColor)
    {
    	if( theColor.equals("white")) {
    		return whitePiecesNumber;	// number of pieces remaining to play for "white"
    	}
    	else if( theColor.equals("black")) {
    		return blackPiecesNumber;	// number of pieces remaining to play for "black"
    	}
    	else {
    		System.out.println("*** Error in piecesRemainingToPlayFor()");
    		System.exit( -1);
    	}
    	return 0 ;
    }
    
    
    /**
     * Update one of the number of pieces labels, either at the top or bottom of playing window.
     * Build a text string that has at the front the text:<br>
     * "   Remaining to play for" <br>
     * and then add to that the string "white" or "black", and then add to that the new value.
     * Use this string to change the label either at the top or bottom of the playing window.
     * 
     * @param theColor 	the color ("black" or "white") of the piece label to be updated
     * @param newValue	the new number value to be displayed at the end of the label
     */
    public void updatePiecesDisplay(String theColor, int newValue)
    {
    	String theText = "  Remaining to play for " + theColor + ": " + newValue;
    	if( theColor.equals("white")) {
    		whitePiecesDisplay.setLabel( theText);
    	}
    	else {
    		blackPiecesDisplay.setLabel( theText);
    	}
    }
    
    
    /**
     * Get a new piece (if there still are any remaining) and place it at the indicated position.
     * Note that positions are displayed on the board as 1..20.  Given this value, we can
     * calculate the row and colum as follows: <br>
     * 		row = (thePosition-1) / NUMBER_OF_COLUMNS; <br>
     *  	column = (thePosition-1) % NUMBER_OF_COLUMNS; <br>
     * (Remember that NUMBER_OF_COLUMNS is 5.)  For example, an index of 8 would give row 1 
     * and column 2, which is correct from the point of view of the top row being row 0 
     * and the left column being column 0. 
     * <p>
     * Using these row and column values, we can calculate the x,y position for the piece
     * to be placed using the formula: <br>
     *		x = STARTING_X_VALUE + (SQUARE_SIZE + OFFSET) * column; <br>
     *		y = SQUARE_SIZE + (SQUARE_SIZE + OFFSET) * row; <br>
     * 
     * @param 	theColor	color of piece ("white" or "black") to be placed
     * @param	thePosition	the position (1..20) where it should be placed
     * @return				whether or not there was a piece that could be placed
     */
    public boolean placePieceSuccessfully(String theColor, int thePosition)
    {
    	// find the x,y values corresponding to thePosition.  First extract the row and column numbers from thePosition
    	int row = (thePosition-1) / NUMBER_OF_COLUMNS;
    	int column = (thePosition-1) % NUMBER_OF_COLUMNS;
    	
    	// Now use the row and column values in the formula used to calculate position
    	int x = STARTING_X_VALUE + (SQUARE_SIZE + OFFSET) * column;
    	int y = SQUARE_SIZE + (SQUARE_SIZE + OFFSET) * row;
            	
       	// see whose move it is, and ensure there are still pieces to be placed
    	if( theColor.equals("black")) {
            if( blackPiecesNumber > 0) {
	    		// make the appropriate next piece placed in the requested position and visible
	    		blackPieces[ 8-blackPiecesNumber].setCircleValues(x, y, true);
	    		// record the new index of this piece
	    		blackPieces[ 8-blackPiecesNumber].setBoardPosition( thePosition);
		 		// decrement the count of black pieces and update that display on the playing board
		 		blackPiecesNumber--;
		 		updatePiecesDisplay( "black", blackPiecesNumber);
		 		return true;
    		}
            else {
            	System.out.println("Sorry, but you have no more pieces to place.");
            }
    	}
    	else {
    		// color must be "white"
    		if( whitePiecesNumber > 0) {
	    		// make the appropriate next piece placed in the requested position and visible
	    		whitePieces[ 8-whitePiecesNumber].setCircleValues(x, y, true);
	    		// record the new index of this piece
	    		whitePieces[ 8-whitePiecesNumber].setBoardPosition( thePosition);
		 		// decrement the count of white pieces and update that display on the playing board
		 		whitePiecesNumber--;
		 		updatePiecesDisplay( "white", whitePiecesNumber); 
		 		return true;
    		}
    		else {
    			System.out.println("Sorry, but you have no more pieces to place.");
    		}
    	}
    	
    	// We were not able to place a piece, because there are no more to be placed
    	return false;
    }//end placeString(...
    
    
    /**
     * Find the color ("black" or "white") of a piece at a particular board index,
     * or "" if there is no piece there.
     * 
     * @param 	theIndex	board index 1..20 of the playing position in question
     * @return				the color ("white" or "black") of the piece, or "" if no piece there	
     */
    public String colorOfPieceAt( int theIndex)
    {
    	// go through all the black and white pieces, looking for this index.  If found,
    	// then the square is not free.
    	for( int i=0; i<blackPieces.length; i++) {
    		// could just as well used whitePieces.length above, as their sizes are the same
    		if( blackPieces[i].getBoardPosition() == theIndex) {
    			return "black";
    		}
    		else if( whitePieces[i].getBoardPosition() == theIndex) {
    			return "white";
    		}
    	}//end for( int i...
    	
    	// if we got here, no matching piece was found so return the default
    	return "";
    }
    
 
    /**
     * return the Piece at the indicated board position.
     * 
     * @param theIndex	index of the piece for which we are looking
     * @return			reference to the actual Piece
     */
    public Piece getPieceAt( int theIndex)
    {
    	// go through all the black and white pieces, looking for this index.  If found,
    	// then return the piece at that location
    	for( int i=0; i<blackPieces.length; i++) {
    		// could just as well used whitePieces.length above, as their sizes are the same
    		if( blackPieces[i].getBoardPosition() == theIndex) {
    			return blackPieces[i];
    		}
    		else if( whitePieces[i].getBoardPosition() == theIndex) {
    			return whitePieces[i];
    		}
    	}//end for( int i...
    	
    	// if we got here, no matching piece was found so return the default
    	return null;
    }
    
    
    /**
     * Remove the indicated piece from the board when a piece is jumped.  
     * The piece's board position should be set to -1 (off the board) and it 
     * should be set to invisible.
     * 
     * @param theIndex	index of the piece to be removed.
     */
    public void removePieceAt( int theIndex)
    {
    	// create a reference (like a synonym) to the piece in question
    	Piece thePiece = getPieceAt( theIndex);
    	
    	// if the piece exists, set the piece's board position to -1 and make it invisible.
    	if( thePiece != null) {
	    	thePiece.setBoardPosition( -1);
	    	// make the piece invisible
	    	thePiece.setVisibility( false);
    	}
    }
    
}// end class Board()