/*
 * Copyright (c) 1998 Kevan Stannard. All Rights Reserved.
 *
 * Permission to use, copy, modify, and distribute this software
 * and its documentation for NON-COMMERCIAL or COMMERCIAL purposes and
 * without fee is hereby granted. 
 * 
 * Please note that this software comes with
 * NO WARRANTY 
 *
 * BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED
 * BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
 * PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
 * TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME
 * THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 
 * 
 * IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER
 * PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
 * INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE
 * THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED
 * BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER
 * OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 */

import java.awt.*;
import java.awt.image.*;
import java.applet.*;
import java.net.*;

class Tile extends Panel
{
	Image image;
	int width;
	int height;

	MediaTracker tracker;

	public Tile(Image i, int w, int h)
	{
		image = i;
		width = w;
		height = h;

		tracker = new MediaTracker(this);
		tracker.addImage(i,0);
		tracker.checkAll(true);
	}

	public final void draw(Graphics g, int x, int y)
	{
		g.drawImage(image,x,y,null);
	}

	public final String toString()
	{
		return image.toString();
	}

	public final boolean check()
	{
		if (tracker == null)
		{
			return true;
		}
		else
		{
			if (tracker.checkAll())
			{
				tracker = null;
				return true;
			}
		}
		return false;
	}

	public final void addBorder()
	{
		int numPixels;
		int pix[];
		numPixels = width*height;
		pix = new int[numPixels+1];

		// grab the pixels

		PixelGrabber pg = new PixelGrabber(image,0,0,width,height,pix,0,width);
		try
		{
			pg.grabPixels();
		}
		catch (InterruptedException e)
		{
		}

		// process the pixels

		for (int p=0; p<numPixels; p++)
		{
			int a = (pix[p] & 0xff000000) >> 32;
			int r = (pix[p] & 0x00ff0000) >> 16;
			int g = (pix[p] & 0x0000ff00) >> 8;
			int b = (pix[p] & 0x000000ff);

			if (p<width || (p%width)==0)
			{
				r <<= 1;
				g <<= 1;
				b <<= 1;
				if (r>255) r=255;
				if (g>255) g=255;
				if (b>255) b=255;
			}

			if (p>=(numPixels-width) || (p%width)==width-1)
			{
				r >>= 1;
				g >>= 1;
				b >>= 1;
				if (r<0) r=0;
				if (g<0) g=0;
				if (b<0) b=0;
			}

			pix[p] = (a << 32) | (r << 16) | (g << 8) | (b);
		}

		// create new image

		image = createImage(new MemoryImageSource(width,height,pix,0,width));
	}

	public final void darken()
	{
		int numPixels;
		int pix[];
		numPixels = width*height;
		pix = new int[numPixels+1];

		// grab the pixels

		PixelGrabber pg = new PixelGrabber(image,0,0,width,height,pix,0,width);
		try
		{
			pg.grabPixels();
		}
		catch (InterruptedException e)
		{
		}

		// process the pixels

		for (int p=0; p<numPixels; p++)
		{
			int a = (pix[p] & 0xff000000) >> 32;
			int r = (pix[p] & 0x00ff0000) >> 16;
			int g = (pix[p] & 0x0000ff00) >> 8;
			int b = (pix[p] & 0x000000ff);

			r >>= 1;
			g >>= 1;
			b >>= 1;
			if (r<0) r=0;
			if (g<0) g=0;
			if (b<0) b=0;

			pix[p] = (a << 32) | (r << 16) | (g << 8) | (b);
		}

		// create new image

		image = createImage(new MemoryImageSource(width,height,pix,0,width));
	}
}

public class JZOOTileWork extends Applet implements Runnable
{
	// applet 

	int appletWidth = 0;
	int appletHeight = 0;

	// thread 

	Thread thread;

	// main image 

	String imageName;
	Image image;
	int imageWidth;
	int imageHeight;

	// tiles

	final int TILES_ACROSS = 4;
	final int TILES_DOWN = 4;

	int tileWidth;
	int tileHeight;

	int blankTile;
	int blankx;
	int blanky;

	Tile tile[] = new Tile[TILES_ACROSS * TILES_DOWN];
	int matrix[][] = new int[TILES_ACROSS][TILES_DOWN];

	// double buffer

	Image db;
	Graphics dbGraphics;

	// blank tile glow

	int glow = 0;
	int glowDirection = 16;

	// image tracker

	MediaTracker tracker;

	// status

	final int LOADING_IMAGES = 1;
	final int START_CREATING_TILES = 2;
	final int CREATING_TILES = 3;
	final int READY = 4;
	final int GAME_FINISHED = 5;

	int status = 0;

	// time

	int time;
	int gameCounter;

	// font

	Font font;
	FontMetrics fm;
	int textWidth;
	int textAscent;
	int textDescent;

	public void init()
	{
		appletWidth = Integer.parseInt(getParameter("width"));
		appletHeight = Integer.parseInt(getParameter("height"));
		imageName = getParameter("imageName");

		db = createImage(appletWidth, appletHeight);
		dbGraphics = db.getGraphics();

		font = new Font("Ariel",Font.BOLD,14);
		fm = getFontMetrics(font);
	}

	public void start()
	{
		if (thread == null)
		{
			thread = new Thread(this);
		}
		thread.start();
	}

	public void stop()
	{
		if (thread != null)
		{
			thread.stop();
		}
	}

	public void update(Graphics g)
	{
		paint(dbGraphics);
		g.drawImage(db,0,0,null);
	}

	public void paint(Graphics g)
	{
		g.setFont(font);

		if (status == READY)
		{
			int i=0;
			int tileNum;
			for (int y=0; y<TILES_DOWN; y++)
			{
				for (int x=0; x<TILES_ACROSS; x++)
				{
					tileNum = matrix[x][y];
					if (tileNum==blankTile)
					{
						g.setColor(Color.black);
						g.fillRect(x*tileWidth, y*tileHeight, tileWidth, tileHeight);
						
						g.setColor(new Color(glow,0,0));
						g.drawRect(x*tileWidth,y*tileHeight,tileWidth-1, tileHeight-1);
						
						glow += glowDirection;
						if (glow < 0)
						{
							glow = 0;
							glowDirection = 32;
						}
						if (glow > 255)
						{
							glow = 255;
							glowDirection = -32;
						}

						// draw the timer

						String s = "" + time;
						textWidth = fm.stringWidth(s);
						textAscent = fm.getAscent();
						textDescent = fm.getDescent();

						int xoff = (tileWidth - textWidth) / 2;
						int yoff = textAscent + (tileHeight - (textAscent + textDescent)) / 2;

						g.setColor(Color.red);
						g.drawString(s,(x*tileWidth)+xoff,(y*tileHeight)+yoff);
					}
					else
					{
						tile[tileNum].draw(g, x*tileWidth, y*tileHeight);
					}
				}
			}
		}
		else
		if (status == GAME_FINISHED)
		{
			int i=0;
			int tileNum;
			for (int y=0; y<TILES_DOWN; y++)
			{
				for (int x=0; x<TILES_ACROSS; x++)
				{
					tileNum = matrix[x][y];
					if (tileNum==blankTile)
					{
						g.setColor(Color.black);
						g.fillRect(x*tileWidth, y*tileHeight, tileWidth, tileHeight);

						// draw the ranking text

						String s1,s2;
						if (time<30)
						{
							s1 = "You are truly";
							s2 = "MASTER O' THE TILES!";
						}
						else
						if (time<45)
						{
							s1 = "You rank deservedly";
							s2 = "as a TILE BEAST!";
						}
						else
						if (time<60)
						{
							s1 = "You have achieved rank";
							s2 = "of TILE ADEPT";
						}
						else
						if (time<90)
						{
							s1 = "You have achieved the";
							s2 = "magnificent rank of POOBAR";
						}
						else
						{
							s1 = "Congratulations on finishing";
							s2 = "... eventually :)";
						}

						textWidth = fm.stringWidth(s1);
						textAscent = fm.getAscent();
						textDescent = fm.getDescent();
						int xoff = (appletWidth - textWidth) / 2;
						int yoff = 40;
						g.setColor(Color.black);
						g.drawString(s1,xoff+1,yoff+1);
						g.setColor(Color.yellow);
						g.drawString(s1,xoff,yoff);

						textWidth = fm.stringWidth(s2);
						textAscent = fm.getAscent();
						textDescent = fm.getDescent();
						xoff = (appletWidth - textWidth) / 2;
						yoff += (textAscent + textDescent);
						g.setColor(Color.black);
						g.drawString(s2,xoff+1,yoff+1);
						g.setColor(Color.yellow);
						g.drawString(s2,xoff,yoff);
					
					}
					else
					{
						tile[tileNum].draw(g, x*tileWidth, y*tileHeight);
					}
				}
			}
		}
		else
		{
			g.setColor(Color.black);
			g.fillRect(0,0,appletWidth,appletHeight);
			g.setColor(Color.red);
			g.drawString("Loading ... "+ (READY - status),20,20);
		}
	}

	public boolean mouseDown(Event e, int x, int y)
	{
		if (status == READY)
		{
			int tilex = (int) (x / tileWidth);
			int tiley = (int) (y / tileHeight);

			if((((tilex-1) == (blankx)) && ((tiley) == (blanky))) ||
			   (((tilex+1) == (blankx)) && ((tiley) == (blanky))) ||
			   (((tilex) == (blankx)) && ((tiley-1) == (blanky))) ||
			   (((tilex) == (blankx)) && ((tiley+1) == (blanky))))
			{
				matrix[blankx][blanky] = matrix[tilex][tiley];
				matrix[tilex][tiley] = blankTile;
				blankx = tilex;
				blanky = tiley;
			}
	
			return true;
		}

		return false;
	}

	public boolean gameFinished()
	{
		// is the game finished?
	
		boolean done = true;
		int tileNum = 0;
		for (int y=0; y<TILES_DOWN; y++)
		{
			for (int x=0; x<TILES_ACROSS; x++)
			{
				if (tileNum != blankTile)
				{
					done &= (matrix[x][y] == tileNum);
				}

				tileNum++;
			}
		}

		return done;
	}


	public final Image getImage(Image i, int x, int y, int w, int h)
	{
		CropImageFilter cropFilter = new CropImageFilter(x, y, w, h);
		return createImage( new FilteredImageSource(i.getSource(), cropFilter) );
	}

	public void run()
	{

		blankTile = TILES_ACROSS*TILES_DOWN-1;
		int i=(TILES_ACROSS*TILES_DOWN)-1;
		for (int y=0; y<TILES_DOWN; y++)
		{
			for (int x=0; x<TILES_ACROSS; x++)
			{
				matrix[x][y] = i;
				if (i==blankTile)
				{
					blankx = x;
					blanky = y;
				}
				i--;
			}
		}

		time = 0;
		gameCounter = 0;

		// get main image data

		tracker = new MediaTracker(this);
		image = getImage(getCodeBase(), imageName);
		tracker.addImage(image,0);

		status = LOADING_IMAGES;

		while (true)
		{

			repaint();

			gameCounter++;

			if (status == LOADING_IMAGES)
			{
				if (tracker.checkAll(true))
				{
					imageWidth = image.getWidth(this);
					imageHeight = image.getHeight(this);
					tileWidth = imageWidth / TILES_ACROSS;
					tileHeight = imageHeight / TILES_DOWN;

					tracker = null;
					status = START_CREATING_TILES;
				}
			}

			if (status == START_CREATING_TILES)
			{
				i=0;
				for (int y=0; y<TILES_DOWN; y++)
				{
					for (int x=0; x<TILES_ACROSS; x++)
					{
						Image tileImage = getImage(image, x*tileWidth, y*tileHeight, tileWidth, tileHeight);
						tile[i] = new Tile(tileImage, tileWidth, tileHeight);
						i++;
					}
				}

				status = CREATING_TILES;
			}

			if (status == CREATING_TILES)
			{
				boolean checkAll = true;
				i=0;
				for (int y=0; y<TILES_DOWN; y++)
				{
					for (int x=0; x<TILES_ACROSS; x++)
					{
						checkAll &= tile[i].check();
						i++;
					}
				}

				if (checkAll)
				{
					i=0;
					for (int y=0; y<TILES_DOWN; y++)
					{
						for (int x=0; x<TILES_ACROSS; x++)
						{
							tile[i].addBorder();
							i++;
						}
					}
					status = READY;
				}
			}

			if (status==READY)
			{
				// is the game finished?

				if (gameFinished())
				{
					i=0;
					for (int y=0; y<TILES_DOWN; y++)
					{
						for (int x=0; x<TILES_ACROSS; x++)
						{
							tile[i].darken();
							i++;
						}
					}

					status = GAME_FINISHED;
				}
	
				if (gameCounter%10==0)
				{
					time++;
				}
			}

			try
			{
				thread.sleep(100);
			}
			catch (InterruptedException e)
			{
			}
		}
	}

}