//
//  SimplePuzzle.java
//  Difficult Puzzle
//
//  Created by Matthew Fahrenbacher on 8/14/04.
//  Copyright 2004 __MyCompanyName__. All rights reserved.
//

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

public class SimplePuzzle 
{
	private Rectangle[] rects;
	
	private static final int BOXES_WIDE = 4;
	private static final int BOXES_HIGH = 5;
	
	private ArrayList descendents = new ArrayList();
	private ArrayList ancestors = new ArrayList();
	
	private ArrayList moves = new ArrayList();
	
	public SimplePuzzle()
	{
		rects = new Rectangle[10];
		
		//verticals
		rects[0] = new Rectangle(0,0,1,2);
		rects[1] = new Rectangle(0,2,1,2);
		rects[2] = new Rectangle(3,0,1,2);
		rects[3] = new Rectangle(3,2,1,2);
		
		//mini-squares
		rects[4] = new Rectangle(0,4,1,1);
		rects[5] = new Rectangle(1,3,1,1);
		rects[6] = new Rectangle(2,3,1,1);
		rects[7] = new Rectangle(3,4,1,1);
		
		//big square
		rects[8] = new Rectangle(1,0,2,2);
		
		//horizontal
		rects[9] = new Rectangle(1,2,2,1);
	}
	
	public SimplePuzzle(SimplePuzzle copy)
	{
		rects = new Rectangle[10];
		
		for(int i=0; i<copy.rects.length; i++)
			rects[i] = new Rectangle(copy.rects[i].x,
									 copy.rects[i].y,
									 copy.rects[i].width,
									 copy.rects[i].height);
									 
		Iterator iter = copy.moves.iterator();
		while(iter.hasNext())
			moves.add(iter.next());
	}
	
	public ArrayList moves()
	{
		return moves;
	}
	
	public int numMoves()
	{
		return moves.size();
	}
	
	public boolean hasWon()
	{
		return rects[8].x == 1 && rects[8].y == 3;
	}
	
	public void addAncestor(SimplePuzzle p)
	{
		ancestors.add(p);
	}
	
	public void addDescendent(SimplePuzzle p)
	{
		descendents.add(p);
	}
	
	public Iterator getAncestors()
	{
		return ancestors.iterator();
	}
	
	public Iterator getDescendents()
	{
		return descendents.iterator();
	}
	
	public boolean equals(SimplePuzzle copy)
	{
		//true if the 2x2's are in the same place as well
		//as the 1x2. The 1x1s and 2x1's can be changed around...
		
		//2x2 and 1x2
		if(!rects[8].equals(copy.rects[8]) || !rects[9].equals(copy.rects[9]))
			return false;
			
		//4 2x1's
		for(int i=0; i<4; i++)
		{
			int j;
			for(j=0; j<4; j++)
				if(rects[i].equals(copy.rects[j]))
					break;
					
			if(j == 4)
				return false;
		}
		
		//4 1x1's
		for(int i=4; i<8; i++)
		{
			int j;
			for(j=4; j<8; j++)
				if(rects[i].equals(copy.rects[j]))
					break;
					
			if(j == 8)
				return false;
		}
		
		return true;
	}
	
	public void movePieceInDirection(int pieceID, char dir)
	{
		Rectangle r = rects[pieceID];
		Rectangle newRect;
		
		switch(dir)
		{
			case 'w':	newRect = new Rectangle(r.x, r.y-1, r.width, r.height); break;
			case 's':	newRect = new Rectangle(r.x, r.y+1, r.width, r.height); break;
			case 'a':	newRect = new Rectangle(r.x-1, r.y, r.width, r.height); break;
			case 'd':	newRect = new Rectangle(r.x+1, r.y, r.width, r.height); break;
			default:	return;
		}
		
		rects[pieceID] = newRect;
		
		moves.add(new Move(pieceID, dir));
	}
	
	public boolean canMovePieceInDirection(int pieceID, char dir)
	{
		Rectangle r = rects[pieceID];
		Rectangle newRect;
		
		switch(dir)
		{
			case 'w':	newRect = new Rectangle(r.x, r.y-1, r.width, r.height); break;
			case 's':	newRect = new Rectangle(r.x, r.y+1, r.width, r.height); break;
			case 'a':	newRect = new Rectangle(r.x-1, r.y, r.width, r.height); break;
			case 'd':	newRect = new Rectangle(r.x+1, r.y, r.width, r.height); break;
			default:	return false;
		}
		
		if(newRect.x < 0 || 
		   newRect.y < 0 ||
		   newRect.x + newRect.width > BOXES_WIDE ||
		   newRect.y + newRect.height > BOXES_HIGH)
		{
			return false;
		}
		
		for(int i=0; i<rects.length; i++)
		{
			if(i == pieceID)
				continue;
				
			if(rects[i].intersects(newRect))
				return false;
		}
		
		return true;
	}
}