/**
 * A Board "paints" the screen background and then uses two arrays of pieces,
 * one for white and one for black.
 * 
 * @author Dale Reed 
 * @version October 24, 2008
 */

import java.util.Scanner;
import java.util.Random;          // allows getting a random number


public class Board
{
    // instance variables
    static final int NUMBER_OF_ROWS = 3;
    static final int NUMBER_OF_COLUMNS = 3;
    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 = 30; 
    static final int STARTING_Y_VALUE = 40;
    static final int NUMBER_OF_PIECES = 9;
    
    // values to be used when explicitly setting board tile values.  The first value becomes the
    // label for the upper-left corner, then labels are assigned row by row.
    static final int[] startPositionValues = {3,2,7,
                                              5,8,4,
                                              6,1,0};
    
    Square[] pieces = new Square[ NUMBER_OF_PIECES];
    Square theInvisibleSquare;      // will point to the Square with index 9, which is invisible
    
    // create a random number generator
    Random randomNumberGenerator = new Random(1); 
    
    /***
     * Default constructor that "paints" board background and initializes arrays of pieces.
     * <p>
     * Constructor first allocates memory for each of the 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>
     * Display the title at the top of the window
     * <br>
     * Next create the large black background rectangle, of width,height size: <br>
     *  (SQUARE_SIZE+OFFSET)*NUMBER_OF_PIECES + 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>
     *
     */
    //----------------------------------------------------------------------------------------
    public Board()
    {   
        // Create the top middle label
        Square title = new Square( 105, -10, SQUARE_SIZE, "white", true, "9 Tiles Puzzle");
                                       
        // 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;
        Square background = new Square( x-OFFSET, y-OFFSET,
                                        (SQUARE_SIZE+OFFSET)*NUMBER_OF_ROWS + OFFSET,
                                        "black", true, "");
        
        // Draw the playing pieces themselves
        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...
                int index = (row * NUMBER_OF_ROWS) + columns;
                // create the square for all 9 pieces (indexed 0..8)
                pieces[ index] = new Square( x + (SQUARE_SIZE + OFFSET) * columns, 
                                             y + (SQUARE_SIZE + OFFSET) * row, 
                                             SQUARE_SIZE, "lightGray", true, ""+startPositionValues[ index]);
                // make the last square invisible, and keep track of a reference to it
                if( index == (NUMBER_OF_PIECES-1)) {
                    pieces[ index].makeInvisible();
                    theInvisibleSquare = pieces[ index];    // point to this square, for later use
                }
            }//end for( int columns...
        }//end for( int rows...
 
    }//end constructor Board()
    
    
    //----------------------------------------------------------------------------------------
    public void randomizeBoard()
    {
        // Randomize the ordering of the Square labels.  Do this by generating a random number,
        // and then a second different random number, swapping the labels on the corresponding
        // squares.
        int theFirstRandomNumber = 0;
        int theSecondRandomNumber = 0;
        // repeat the label swapping multiple times, to make sure they are well mixed up
        for( int i=0; i<NUMBER_OF_PIECES; i++) {
            // get the first random number
            theFirstRandomNumber = getRandomNumber();
            // get the second random number, keeping trying if it is the same as the first
            // or if it is the blank square
            do {
                theSecondRandomNumber = getRandomNumber();  
            } while( (theSecondRandomNumber == theFirstRandomNumber));
            
            // Now swap the labels on these two Squares
            String firstValue = pieces[ theFirstRandomNumber].getLabel();
            String secondValue = pieces[ theSecondRandomNumber].getLabel();

            pieces[ theFirstRandomNumber].setLabel( secondValue);
            pieces[ theSecondRandomNumber].setLabel( firstValue);            
        }//end for( int i...    
    }//end randomizeBoard()
    
    
    //----------------------------------------------------------------------------------------
    // getRandomNumber()
    private int getRandomNumber()
    {
        int theRandomNumber = randomNumberGenerator.nextInt();    // This is the # of the randomly selected solution
        // ensure it is a positive value
        theRandomNumber = Math.abs( theRandomNumber);
        // put it in the range 0..7
        theRandomNumber = theRandomNumber % 8; 
        
        // return this value
        return theRandomNumber;
    }//end getRandomNumber()
    
    
    //----------------------------------------------------------------------------------------
    // moveSquare() 
    //      Move a square.  This code also does the error checking to make sure that the
    // "blank" square is adjacent to the square we want to move.  If so, we swap the position
    // of the two squares and return a value of 0.
    //      If the blank square is not adjacent, we return a value of -1 after
    // displaying an error message.
    public int moveSquare( int squareIndex)
    {
        // make a reference to the square that we'll be moving
        Square theSquare = getSquareWithIndex( squareIndex);
        
        // Find the difference between the x and y positions of the square we 
        // want to move, and the blank square.  If the blank square is adjacent,
        // then either x or y will be different by exactly (SQUARE_SIZE + OFFSET)
        int xDifference = theInvisibleSquare.getX() - theSquare.getX();
        int yDifference = theInvisibleSquare.getY() - theSquare.getY();
        
        // Verify that exactly one of the x or y differences is (SQUARE_SIZE + OFFSET)
        if( ( (Math.abs(xDifference) == (SQUARE_SIZE + OFFSET)) && (yDifference == 0) ) ||
            ( (Math.abs(yDifference) == (SQUARE_SIZE + OFFSET)) && (xDifference == 0) )  ) {
            // Is a valid move, so swap the selected square and the invisible square
            // Move the visible square
            theSquare.slowMoveVertical( yDifference);
            theSquare.slowMoveHorizontal( xDifference);
            
            // Move the invisible square in the opposite direction
            theInvisibleSquare.slowMoveVertical( yDifference * -1);
            theInvisibleSquare.slowMoveHorizontal( xDifference * -1);            
        }//end if( ( (Math.abs...
        else {
            // invalid move, so display message and return to caller
            System.out.println("*** Sorry, that move is invalid.  Please retry. ***");
            return -1;   
        }       
        
        // default of a valid move means we return 0
        return 0;
    }//end moveSquare()
    
    
    //----------------------------------------------------------------------------------------
    // getSquareWithIndex()
    //      get the square that has a particular index value
    public Square getSquareWithIndex( int index)
    {
        for( int i=0; i<NUMBER_OF_PIECES; i++)  {
            if( pieces[ i].getLabel().equals(""+index)) {
                // found the piece (which is a Square) with the matching label, so return it
                return pieces[ i];
            }
        }//end for( int i...
        
        // default code if no square was found 
        System.out.println("*** Sorry, that index value of " + index + " was not found.  Exiting...\n");
        System.exit( -1);
        
        // keep Java happy
        return null;
    }
    
    
    //----------------------------------------------------------------------------------------
    // Find the square at the selected row and colum.  Use the row and column values to generate
    // the x and y positions for the sought-after square.  Compare these computed x,y values to
    // all the pieces, one by one, until we find the one that matches.  Return the square that
    // matches, or null if no one is found.
    private Square getSquareAtRowCol( int row, int column)
    {
        // x and y values are relative to the upper-left hand corner of the drawn figure, which
        // is represented by STARTING_X_VALUE, STARTING_Y_VALUE.  Multiply the square (+ offset)
        // size by the column number (and similarly for the row as well).
        int x = STARTING_X_VALUE + ((SQUARE_SIZE + OFFSET) * column); 
        int y = STARTING_Y_VALUE + ((SQUARE_SIZE + OFFSET) * row);
        
        // go through all pieces and find the one at the indicated x,y position
        for( int i=0; i<NUMBER_OF_PIECES; i++)  {
            // find the ith square on the board
            Square theSquare = getSquareWithIndex( i);
            // see if this square is at the calculated x,y
            if( (theSquare.getX() == x) && (theSquare.getY() == y) ) {
                // found the piece matching the projected position, so return it
                return pieces[ i];
            }
        }//end for( int i...   
        
        return null;    // default, for when no square is found
    }//end getDestinationSquare()
    
    
}// end class Board()