//JAKE HACKIM
//NICK SUGGS
//2013

import java.applet.Applet;
import java.awt.*;
import java.util.Timer;
import java.util.TimerTask;
import java.util.*;

public class Block extends Applet
{	
	//==================================================//
	//		GLOBAL DECLARATIONS							//
	//==================================================//

	Block blk;
	
	boolean placed = false;
	
	int timer = 0;
	
	int turns = 0;
	
	int b;
	
	int appletWidth = getWidth();
	int appletHeight = getHeight();
	
	int BLOCKSCALE = 10;
	
	int SPAWNX = 5;
	int SPAWNY = 3;

	int blockType;
	
	boolean isClone = false;

	public int[][] locs;

	public Block(int type, int b, boolean cl)
	{				
		blockType = type;
		
		locs = new int[4][2];
				
		switch(type)
		{
			case 1:
				LBlock();
				break;
				
			case 2:
				RLBlock();
				break;
				
			case 3:
				TBlock();
				break;
				
			case 4:
				OBlock();
				break;
				
			case 5:
				SBlock();
				break;
				
			case 6:
				RSBlock();
				break;
				
			case 7:
				LnBlock();
				break;	
		}
		
		this.b = b;
		
		isClone = cl;
	}
	
	public void LBlock()
	{
		//	[1]
		//	[X]
		//	[3][4]
		
		locs[0][0] = SPAWNX;		
		locs[1][0] = SPAWNX;		
		locs[2][0] = SPAWNX;		
		locs[3][0] = SPAWNX+1;		
		
		locs[0][1] = SPAWNY-1;		
		locs[1][1] = SPAWNY;		
		locs[2][1] = SPAWNY+1;		
		locs[3][1] = SPAWNY+1;		
	}
	
	public void RLBlock()
	{
		//	   [1]
		//	   [X]
		//	[4][3]
		
		locs[0][0] = SPAWNX;		
		locs[1][0] = SPAWNX;		
		locs[2][0] = SPAWNX;		
		locs[3][0] = SPAWNX-1;		
		
		locs[0][1] = SPAWNY-1;		
		locs[1][1] = SPAWNY;		
		locs[2][1] = SPAWNY+1;		
		locs[3][1] = SPAWNY+1;		
		
	}
	
	public void TBlock()
	{
		//	[1][X][3]
		//	   [4]
		
		locs[0][0] = SPAWNX-1;		
		locs[1][0] = SPAWNX;		
		locs[2][0] = SPAWNX+1;		
		locs[3][0] = SPAWNX;		
		
		locs[0][1] = SPAWNY;		
		locs[1][1] = SPAWNY;		
		locs[2][1] = SPAWNY;		
		locs[3][1] = SPAWNY+1;		
		
	}
	
	public void OBlock()
	{
		//no rotation
		//	[1][2]
		//	[3][4]
		
		locs[0][0] = SPAWNX;		
		locs[1][0] = SPAWNX+1;		
		locs[2][0] = SPAWNX;		
		locs[3][0] = SPAWNX+1;		
		
		locs[0][1] = SPAWNY;		
		locs[1][1] = SPAWNY;		
		locs[2][1] = SPAWNY+1;		
		locs[3][1] = SPAWNY+1;		
		
	}
	
	public void SBlock()
	{
		//	   [X][1]
		//	[4][3]
		
		locs[0][0] = SPAWNX+1;		
		locs[1][0] = SPAWNX;		
		locs[2][0] = SPAWNX;		
		locs[3][0] = SPAWNX-1;		
		
		locs[0][1] = SPAWNY;		
		locs[1][1] = SPAWNY;		
		locs[2][1] = SPAWNY+1;		
		locs[3][1] = SPAWNY+1;		
	}
	
	public void RSBlock()
	{
		//	[1][X]
		//	   [3][4] 
			
		locs[0][0] = SPAWNX-1;		
		locs[1][0] = SPAWNX;		
		locs[2][0] = SPAWNX;		
		locs[3][0] = SPAWNX+1;		
		
		locs[0][1] = SPAWNY;		
		locs[1][1] = SPAWNY;		
		locs[2][1] = SPAWNY+1;		
		locs[3][1] = SPAWNY+1;		
	}
	
	public void LnBlock()
	{
		//	[1][X][3][4]
		
		locs[0][0] = SPAWNX-1;		
		locs[1][0] = SPAWNX;		
		locs[2][0] = SPAWNX+1;		
		locs[3][0] = SPAWNX+2;		
		
		locs[0][1] = SPAWNY;		
		locs[1][1] = SPAWNY;		
		locs[2][1] = SPAWNY;		
		locs[3][1] = SPAWNY;		
		
	}
	   
    //==================================================//
    //		BLOCK METHODS								//
    //==================================================//
    
	public void drawBlock(Graphics g, Image img, int scale)
	{	
		BLOCKSCALE = scale;
					
		for(int x = 0; x < 4; x++)
		{
			if(locs[x][1] != 0)
				g.drawImage(img, locs[x][0] * BLOCKSCALE + BLOCKSCALE * 10, locs[x][1] * BLOCKSCALE, BLOCKSCALE + 1, BLOCKSCALE + 1, null);
		}
	}
	
	public int getBlockType()
	{
		return blockType;
	}

	//==================================================//
	//		MOVE METHODS								//
	//==================================================//
	
	public void turnC(int b, ArrayList<Block> blocks, int currentBlock)
	{		
		if(b != 3)
		{
			if(!canTurnC(blocks, currentBlock))
			{	
				superFlip();
				superFlip();
				superFlip();
			}
		}
	}
	
	public boolean canTurnC(ArrayList<Block> blocks, int currentBlock)
	{
		Block blk;
		blk = new Block(this.getType(), b, true);

		blk = clone();
		
		superFlip();
		
		if(!isLegal(blocks, currentBlock))
		{
			return false;
		}
			
		return true;
	}
	
	public void superFlip()
	{
		int hold;
		int xDis;
		int yDis;
	
		for(int x = 0; x < 4; x++)
		{
			xDis = locs[x][0] - locs[1][0];
			yDis = locs[x][1] - locs[1][1];
			
			locs[x][0] = locs[1][0] + yDis;
			locs[x][1] = locs[1][1] + xDis;
			
			hold = locs[x][0] - locs[1][0];
			locs[x][0] -= 2 * hold;
		}
	}
	
	public void moveDown()
	{
		if(canMoveDown())
		{
				for(int x = 0; x < 4; x++)
				{
					if(locs[x][1] != 0)
						locs[x][1]++;
				}
				
				repaint();
		}
		else
			placeBlock();
	}
	
	public void moveLeft(int b)
	{
		if(canMoveLeft())
		{				
			if(b != 3)
			{
				for(int x = 0; x < 4; x++)
				{
					locs[x][0]--;
				}	
					
				repaint();
			}
		}	
	}
	
	public void moveRight(int b)
	{
		
		if(canMoveRight())
		{			
			if(b != 3)
			{
				for(int x = 0; x < 4; x++)
				{
					locs[x][0]++;
				}	
					
				repaint();
			}
		}
	}
	
	public void moveUp(int b)
	{
		if(b != 3)
		{
			for(int x = 0; x < 4; x++)
			{
				if(locs[x][1] != 0)
					locs[x][1]--;
			}
			
			repaint();
		}
	}
	
	public boolean canMoveLeft()
	{
		for(int x = 0; x < 4; x++)
		{
			for(int y = 0; y < 1; y++)
			{
				if(locs[x][y] <= 0)
					return false;
			}
		}
		
		return true;
	}
	
	public boolean canMoveRight()
	{
		for(int x = 0; x < 4; x++)
		{
			for(int y = 0; y < 1; y++)
			{
				if(locs[x][y] >= 9)
					return false;
			}
		}
		
		return true;
	}
	
	public boolean canMoveDown()
	{
		for(int x = 0; x < 4; x++)
		{
			for(int y = 1; y < 2; y++)
			{
				if(locs[x][y] > 20)
					return false;
			}
		}
		
		return true;
	}
	
	public boolean canMoveUp()
	{
		for(int x = 0; x < 4; x++)
		{
			if(locs[x][1] <= 0)
				return false;
		}
		
		return true;
	}
	
	public boolean isLegal(ArrayList<Block> blocks, int currentBlock)
	{		
		boolean check = true;
		int current = -1;
		
		for(int x = 0; x < 4; x++)
		{
			if(locs[x][0] < 0 || locs[x][0] > 9)
			{
				check = false;
			}
			
			if(locs[x][1] < 0 || locs[x][1] > 20)
			{
				check = false;
			}
		}
		
		for(Block b : blocks)
		{
			current++;
			
			if(current != currentBlock && currentBlock != 0)
			{
				for(int x = 0; x < 4; x++)
				{
					for(int y = 0; y < 4; y++)
					{
						if(b.locs[x][0] == this.locs[y][0] && b.locs[x][1] == this.locs[y][1])
						{
							check = false;
						}
					}
				}
			}
		}
				
		return check;
	}
	
	//==================================================//
	//		COPY METHODS								//
	//==================================================//
	
	public Block clone()
	{
		return this;
	}
	
	public int getType()
	{
		return blockType;
	}
	
	//==================================================//
	//		BLOCK PLACE METHODS							//
	//==================================================//
	
	public void placeBlock()
	{
		placed = true;
	}
	
	public boolean isPlaced()
	{
		return placed;
	}
}