import java.awt.*;
import java.util.*;

import java.awt.*;
import javax.swing.*;
import javax.swing.border.*;
import java.util.*;
import java.awt.event.*;
import java.io.*;

/*
   Name of Lab: Tetris- Piece Class
   Your Name: Jennette Shepard
   Your Class: Comp Sci 210
   Date: 4/17/08
 
   This class creates the points of the pieces, rotates the pieces, and creates the skirt, which
   shows the lowest bricks of the piece so that they can be colored yellow by the tester. It also
   checks to see if pieces are equals and has getters that return the values to the pieceTester.
   
*/

/**
 An immutable representation of a tetris piece in a particular rotation.
 Each piece is defined by the blocks that make up its body.
 See the Tetris-Architecture.html for an overview.
 
 This is the starter file version -- a few simple things are filled in already
 
 @author    Nick Parlante
 @author        Eric Chown
 @author Laura Toma
 @version   November 30, 2007
*/
public final class Piece {
    /*
      Implementation notes:
      -The starter code does out a few simple things for you
      -Store the body as a Point[] array
      -Do not assume there are 4 points in the body -- use array.length
      to keep the code general
    */
   
    // The body of the piece, each point is a coordinate specifying a block
    private static Point[] body;    
    
    // Each element specifies how high the piece will land in the corresponding column
    private int[] skirt;     
    
    private int width;  // The width of the piece for the current rotation

    private int height; // The height of the piece for the current rotation

    private static Piece next; // The "next" rotation - note this is how a "piece" is really a list
    
    static private Piece[] pieces;  // singleton array of first rotations
    
    private static final int INITIAL_HIGH_VAL = 10;
    private static final int INITIAL_ZERO = 0;
    private static final int NUMBER_OF_BLOCKS = 4;
    
    
    /**
       Defines a new piece given the Points that make up its body.
       Makes its own copy of the array and the Point inside it.  Does
       not set up the rotations.
       
       This constructor is PRIVATE -- if a client wants a piece
       object, they must use Piece.getPieces().  getPieces() will
       therefore make all of the calls to the constructor.
       
       As with all constructors, your variables should be initialized
       here.  This means you'll need to calculate width and height as
       well as setting up the skirt (doing these things once in the
       constructor means you don't have to do them on the fly during
       game play).  The one exception to this is the "next" variable.
       You'll want to set that in the pieceRow method.
    */
   //set height and width
   //set skirt
    private Piece(Point[] points) {
 
        System.out.print("Creating a new piece");
        
        //create the body 
        //body = new Point[points.length];
        //for (int i=0; i< points.length; i++)
            //body[i] = points[i];
        
        printBody(); 
        
        //initial value for height  and width
        height = width = INITIAL_HIGH_VAL; 
        //sets holders equal to actual points
        for(int i = 0; i < body.length; i++){
            int x = (int)(body[i].getX());
            int y = (int)(body[i].getY());
            
            //set height to greatest found value of y
            if(height == INITIAL_HIGH_VAL || height <= y)   height = y+1;
           
            //set width to greatest found  value of x
            if(width == INITIAL_HIGH_VAL || width <= x)  width = x+1;
        }
        System.out.print (" Height = " + height + " Width = " + width);   
        
        //creates the skirt of size width
        skirt = new int[width];
        for (int j=0; j< width; j++) skirt[j]=INITIAL_HIGH_VAL;
        
        for(int j = 0; j < width; j++){   
            for(int i = 0; i < body.length; i++){
                //if the x value is equal to the "x-value"
                //of the skirt, then put the y-value for that
                //x-value into the skirt, if its the lowest
                if((int)(body[i].getX()) == j){
                    int y = (int)(body[i].getY());
                    if(y <= skirt[j]) skirt[j] = y;
                }
            }
        }
        for (int i=0; i< body.length; i++) {
            if (!(body[i].getX() < width)) System.out.println("BAD");
        }
       System.out.println(); 
    }  
    
    
    /**
       Returns the width of the piece measured in blocks.
    */
    public int getWidth() {
        //System.out.println("Piece tester wanted the width.");
        return(width);
    }
    
    /**
       Returns the height of the piece measured in blocks.
    */
    public int getHeight() {
        //System.out.println("Piece tester wanted the height.");
        return(height);
    }
    
    /**
       Returns a pointer to the piece's body. The caller
       should not modify this array.
    */
    public Point[] getBody() {
        System.out.print("GetBody:");
        printBody(); 
        return(body);
    }
    
      public void printBody() {
        System.out.print("Body:");
        for(int i= 0; i<body.length; i++){
            System.out.print("(" + i + ", " + body[i] + ") ");
        }
        System.out.println();
    }
    
    
    /**
       Returns a pointer to the piece's skirt. For each x value across
       the piece, the skirt gives the lowest y value in the body.
       This useful for computing where the piece will land.  The
       caller should not modify this array.
    */
    public int[] getSkirt() {
        System.out.print("GetSkirt:");
        System.out.print(" width=" + width + ", " ); 
        for(int i= 0; i<width; i++){
            System.out.print("(" + i + ", " + skirt[i] + ") ");
        }
        System.out.println();
        
        return(skirt);
    }
    
    
    
    
    /**
       Returns a piece that is 90 degrees counter-clockwise rotated
       from the receiver.
       
       Implementation: The Piece class pre-computes all the rotations
       once.  This method just hops from one pre-computed rotation to
       the next in constant time.
    */  
    public Piece nextRotation() {
        System.out.println("Piece tester has called for the Next piece.");
        return next;
    }
    
    
    /**
       Returns true if two pieces are the same -- their bodies contain
       the same points.  Interestingly, this is not the same as having
       exactly the same body arrays, since the points may not be in
       the same order in the bodies. Used internally to detect if two
       rotations are effectively the same.
    */
    public boolean equals(Piece other) {
        //variable that counts to see if
        //one piece equals the other
        int countTrue = INITIAL_ZERO;
        
        System.out.println("Equals has been asked for");
        //if bodies have different sizes, then they cannot be equal 
        if (body.length != other.getBody().length) return false; 
        
        //looks at all of the points and 
        //checks if they match or not
        for(int i = 0; i< body.length; i++){
            //for every point 
            for(int j = 0; j< other.getBody().length; j++){
                if(body[i] == other.getBody()[j]){
                    countTrue++;
                    //System.out.println("CountTrue = " + countTrue);
                }
            }
        }
        
        //System.out.println((body.length) + " = length & countTrue = " + countTrue);
        
        //if all four points have matched,
        //then it is true
        if(countTrue == body.length){
            System.out.println("the two pieces are equal");
            return true;
        }else{
            System.out.println("They are not equal");
            return false;
        } 
                
    }
    
    /**
     *  This is where most of your work will be done.  pieceRow takes
     *  the initial rotation of a piece and should create all of the
     *  rest of the rotations in a kind of circular list.  Essentially
     *  you get the body array of the initial configuration of the
     *  Piece, you need to calculate the other body arrays.
    */
    public static Piece pieceRow(Piece starter) {
        /*
        System.out.println("STARTER = ");
        for(int i = 0; i<NUMBER_OF_BLOCKS; i ++){
            System.out.println(starter.getBody()[i]);
        }
        System.out.println();
   
        Piece nextRotation = rotate(starter.getBody());
        Piece prev = starter; 
        
        //while the temporary body doesnt equal the orignial
        while(!starter.equals(nextRotation.getBody())){
            
            prev.next = nextRotation; 
            prev  = nextRotation; 
            nextRotation = rotate(nextRotation.getBody());
        }
        if(!starter.equals(nextRotation.getBody())){
            System.out.println("They are equal!!");
        }
        
        //link last to starter 
        prev.next = starter; 
    }    
    */
    starter.next = starter; 
    return starter;
    }
        
    public static Piece rotate(Point[] pieceBody){    
        
        String tempPoints = "";
            
        //how far the piece is off from
        //the origin
        int offVal = INITIAL_ZERO;
            
        //place holders for x and y
        int y = INITIAL_ZERO;
        int x = INITIAL_ZERO;
            
        //calculates the offVal by looking at the
        //new y value that is furthest from the origin
        for(int i = 0; i< NUMBER_OF_BLOCKS; i++){
            y = -(int) pieceBody[i].getX();
            
            if(y < offVal){
                offVal = y;
            }  
        }
            
        //creates the tempbody with new points
        for(int i = 0; i< NUMBER_OF_BLOCKS; i++){
            x = (int) pieceBody[i].getY();
            y = -(int) pieceBody[i].getX();
            tempPoints = tempPoints + x +" " + (y-offVal) + " ";
        }
            
        //returns that point
        return new Piece((parsePoints(tempPoints))); 
        
    }

    
    /**
       Returns an array containing the first rotation of each of the 7
       standard tetris pieces.  The next (counterclockwise) rotation
       can be obtained from each piece with nextRotation().  In this
       way, the client can iterate through all the rotations until
       eventually getting back to the first rotation.
    */
    public static Piece[] getPieces() {
        // Makes seven calls to pieceRow for each of the seven standard Tetris pieces.  
        //Places the results of each call into an array and returns the array.
        pieces = new Piece[] {
            pieceRow(new Piece(parsePoints("0 0 0 1 0 2 0 3"))),    // 0
            pieceRow(new Piece(parsePoints("0 0 0 1 0 2 1 0"))),   // 1
            pieceRow(new Piece(parsePoints("0 0 1 0 1 1 1 2"))),    // 2
            pieceRow(new Piece(parsePoints("0 0 1 0 1 1 2 1"))),    // 3
            pieceRow(new Piece(parsePoints("0 1 1 1 1 0 2 0"))),    // 4
            pieceRow(new Piece(parsePoints("0 0 0 1 1 0 1 1"))),    // 5
            pieceRow(new Piece(parsePoints("0 0 1 0 1 1 2 0"))),    // 6
        };
        return pieces;
    }
    
    
    /**
       Given a string of x,y pairs ("0 0 0 1 0 2 1 0"), parses the
       points into a Point[] array.  (Provided code)
    */
    private static Point[] parsePoints(String string) {

        Vector points = new Vector();
        StringTokenizer tok = new StringTokenizer(string);
        try {
            while(tok.hasMoreTokens()) {
                int x = Integer.parseInt(tok.nextToken());
                int y = Integer.parseInt(tok.nextToken());
        
                points.addElement(new Point(x, y));
            }
        }
        catch (NumberFormatException e) {
            throw new RuntimeException("Could not parse x,y string:" + string); 
            // cheap way to do assert
        }
    
        // Make an array out of the Vector
        Point[] array = new Point[points.size()];
        points.copyInto(array);
        body = array;
        return(array);
    }
    
}