package com.droidquest.items;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Rectangle;
import java.awt.event.InputEvent;
import java.awt.event.KeyEvent;
import java.awt.event.MouseEvent;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

import javax.swing.ImageIcon;
import javax.swing.JPanel;

import com.droidquest.Room;
import com.droidquest.Wire;
import com.droidquest.devices.Device;
import com.droidquest.levels.Level;
import com.droidquest.materials.ChipTrash;

public class Item implements Serializable, Cloneable 
{
	public transient static Level level; 
	public transient Item carrying; // What this item is carrying. 
	public transient Item carriedBy; // What is carrying this item.
	public transient Image currentIcon; // Current image of this item.
	public transient ImageIcon[] icons; // Array of images for this item
	public transient Room room; // Room this item is currently in
	public transient Color outline; // Null, White, Grey
	public transient int automove; // 0=normal movement, 1=Move to autoX,autoY, 2=Move in autoX,autoY
	public transient int autoX; // Destination of automovement
	public transient int autoY; // Destination of automovement
	public Room InternalRoom = null; // Room inside this item, if any.

	protected int repeating=0; // Keyboard repeat.
	public int charge =0; // Battery Charge of this item, if any.
	public boolean grabbable=true; // Can this item be picked up?
	public int x,y; // Position X,Y
	protected int orgX, orgY; // origin, within graphics
	protected int width, height; // width & height of object from origin
	public Rectangle leftPortal;  
	public Rectangle rightPortal; 
	public Rectangle upPortal;    
	public Rectangle downPortal;  
	public boolean editable=false;

	public Item() 
	{
		x=0; y=0;
	}

	public Item(String filename, int X, int Y, Room r) 
	{
		x=X; y=Y;
		room = r;
		grabbable = true;
		//	icons = new Image[1];
		//	icons[0]=Toolkit.getDefaultToolkit().getImage(filename);
		icons = new ImageIcon[1];
		icons[0]=new ImageIcon(filename);
		currentIcon = icons[0].getImage();
	}

	public void writeRef(ObjectOutputStream s) throws IOException 
	{
		s.writeInt(level.items.indexOf(carrying));
		s.writeInt(level.items.indexOf(carriedBy));
		s.writeInt(level.rooms.indexOf(room));
		s.writeInt(level.rooms.indexOf(InternalRoom));
	}

	public void readRef(ObjectInputStream s) throws IOException 
	{
		carrying = level.FindItem(s.readInt());
		carriedBy =  level.FindItem(s.readInt());
		room = level.FindRoom(s.readInt());
		InternalRoom = level.FindRoom(s.readInt());
		GenerateIcons();
	}

	public Image getIcon() 
	{
		return currentIcon;
	}

	public int getWidth() 
	{
		return width;
	}

	public int getHeight() 
	{
		return height;
	}

	public int getX() 
	{
		return (x-orgX);
	}

	public int getY() 
	{
		return (y-orgY);
	}

	public Room getRoom() 
	{
		return room;
	}

	public void PicksUp(Item item) 
	{
		// This picks up an item
		if (carrying == null)
			if (item.CanBePickedUp(this) == true && item.carriedBy == null)
			{
				carrying = item;
				item.carriedBy = this;
				item.x -= x;
				item.y -= y;
				item.outline=Color.white;
				level.PlaySound(room,Level.PICKUPSOUND);
			}
	}

	public void Drops() 
	{
		// This drops the carried item
		if (carrying != null)
		{
			Item item = carrying;
			carrying.carriedBy = null;
			Dimension d = GetXY();
			carrying.x += d.width;
			carrying.y += d.height;
			if (carrying.x<0)
			{
				carrying.x += 560;
				carrying.room = room.leftRoom;
			}
			if (carrying.y<0)
			{
				carrying.y += 384;
				carrying.room = room.upRoom;
			}
			if (carrying.x>559)
			{
				carrying.x -= 560;
				carrying.room = room.rightRoom;
			}
			if (carrying.y>383)
			{
				carrying.y -= 384;
				carrying.room = room.downRoom;
			}
			carrying = null;
			outline=new Color(128,128,128);
			item.IsDropped();
			level.PlaySound(room, Level.DROPSOUND);
		}
	}

	public void IsDropped() 
	{
		if (!editable) return;

		int bigXl = (x)/28;
		int bigXr = (x+width-1)/28;
		int bigYt = (y)/32;
		int bigYb = (y+height-1)/32;

		if (bigXr>19) bigXr=19;
		if (bigYb>11) bigYb=11;

		for (int a=bigYt; a<=bigYb; a++)
			for (int b=bigXl; b<=bigXr; b++)
			{
				if (room.MaterialArray[a][b] instanceof ChipTrash)
				{
					SetRoom(null); // Cheap way to remove the wires;
					level.items.removeElement(this);
					level.PlaySound(room,Level.DISCHARGESOUND);
					return;
				}
			}

		return;
	}

	public void SetRoom(Room r) 
	{
		// Goes through recursively from Item to carried item to carried
		// item.... Puts all items in the same room.
		Room cr = r;
		if (r != room)
			if (isDevice())
			{
				Device device = (Device) this;
				for (int a = 0; a<device.ports.length; a++)
					if (device.ports[a].myWire != null)
					{
						Wire wire = device.ports[a].myWire;
						wire.Remove();
					}
			}
		if (carriedBy == null)
		{
			if (x<0)    { cr=r.leftRoom; x+=560; }
			if (y<0)    { cr=r.upRoom; y+=384; }
			if (x>=560) { cr=r.rightRoom; x-=560; }
			if (y>=384) { cr=r.downRoom; y-=384; }
		}
		room = cr;
		automove=0;
		if (carrying != null)
			carrying.SetRoom(cr);
	}

	public boolean KeyUp(KeyEvent e) 
	{
		// Handles keybord input.
		// Return TRUE if repaint is needed (usually for movement)
		return false;
	}

	public boolean KeyDown(KeyEvent e) 
	{
		// Handles keybord input.
		// Return TRUE if repaint is needed (usually for movement)
		return false;
	}

	public void MouseClick(MouseEvent e) 
	{
		int button=0;
		if ((e.getModifiers() & InputEvent.BUTTON1_MASK) == InputEvent.BUTTON1_MASK)
			button = 1;
		if ((e.getModifiers() & InputEvent.BUTTON3_MASK) == InputEvent.BUTTON3_MASK)
			button = 3;

		if (button==1)
		{
			if (e.getClickCount()==1)
			{
				autoX = e.getX() - width/2;
				autoY = e.getY() - height/2;
				autoX -= autoX%2; // Even numbered pixel only!
				autoY -= autoY%2;
				automove = 1;
			}
			else if (e.getClickCount()==2)
			{
				int dx = e.getX() - width/2 - x;
				int dy = e.getY() - height/2 - y;
				if (Math.abs(dx) > Math.abs(dy))
				{
					autoY=0; autoX=28;
					if (dx<0) autoX=-28;
					automove=2;
				}
				else
				{
					autoX=0; autoY=32;
					if (dy<0) autoY=-32;
					automove=2;
				}
			}
		}

		if (button==3)
		{
			KeyEvent k = new KeyEvent(e.getComponent(), e.getID(), 
					e.getWhen(), 0, 
					KeyEvent.VK_SPACE,' ');
			KeyUp(k);
		}

	}

	public void MoveUp(int dist) 
	{
		int bigXl = x/28;
		int bigXr = (x+getWidth()-1)/28;
		int bigY  = (y-dist)/32;
		if (   (level.materialAt(bigXl,bigY,room).Passable(this) == false)
				|| (level.materialAt(bigXr,bigY,room).Passable(this) == false) )
		{
			automove=0;
			int newDist = y - (bigY+1)*32;
			y = (bigY+1)*32;
			ItemEffectsMaterials();
			return;
		}
		y=y-dist;
		if (y<0)
		{
			if (room.getUpRoom(this) != null)
			{ // change Rooms
				y=y+384;
				SetRoom(room.getUpRoom(this));
			}
			else if (this==level.player && room.portalItem != null)
			{ // Exit item, Player only
				Dimension d = room.portalItem.GetXY();
				x = d.width + (room.portalItem.width - width)/2;
				y = d.height + (room.portalItem.height - height)/2;
				SetRoom(room.portalItem.room);
				MoveUp(dist);
			}
			else
			{ // stop at top
				y+=384;
				automove=0;
			}
		}
		ItemEffectsMaterials();
	}

	public void MoveDown(int dist) 
	{
		int bigXl = x/28;
		int bigXr = (x+getWidth()-1)/28;
		int bigY  = (y+getHeight()-1+dist)/32;
		if (   (level.materialAt(bigXl,bigY,room).Passable(this) == false)
				|| (level.materialAt(bigXr,bigY,room).Passable(this) == false) )
		{
			automove=0;
			int newDist = bigY*32 - getHeight() - y;
			y += newDist;
			ItemEffectsMaterials();
			return;
		}
		y=y+dist;
		if (y>383)
		{
			if (room.getDownRoom(this) != null)
			{ // change Rooms
				y=y-384;
				SetRoom(room.getDownRoom(this));
			}
			else if (this==level.player && room.portalItem != null)
			{ // Exit item, GameCursor only
				Dimension d = room.portalItem.GetXY();
				x = d.width + (room.portalItem.width - width)/2;
				y = d.height + (room.portalItem.height - height)/2;
				SetRoom(room.portalItem.room);
				MoveDown(dist);
			}
			else
			{ // stop at bottom
				y-=384;
				automove=0;
			}
		}
		ItemEffectsMaterials();
	}

	public void MoveLeft(int dist) 
	{
		int bigX = (x-dist)/28;
		int bigYt = y/32;
		int bigYb = (y+getHeight()-1)/32;
		if (   (level.materialAt(bigX,bigYt,room).Passable(this) == false)
				|| (level.materialAt(bigX,bigYb,room).Passable(this) == false) )
		{
			automove=0;
			int newDist = x - (bigX+1)*28 ;
			x = (bigX+1)*28;
			ItemEffectsMaterials();
			return;
		}
		x=x-dist;
		if (x<0)
		{
			if (room.getLeftRoom(this) != null)
			{ // change Rooms
				x=x+560;
				SetRoom(room.getLeftRoom(this));
			}
			else if (this==level.player && room.portalItem != null)
			{ // Exit item, GameCursor only
				Dimension d = room.portalItem.GetXY();
				x = d.width + (room.portalItem.width - width)/2;
				y = d.height + (room.portalItem.height - height)/2;
				SetRoom(room.portalItem.room);
				MoveLeft(dist);
			}
			else
			{ // stop at Left
				x+=560;
				automove=0;
			}
		}
		ItemEffectsMaterials();
	}

	public void MoveRight(int dist) 
	{
		int bigX = (x+getWidth()-1+dist)/28;
		int bigYt = y/32;
		int bigYb = (y+getHeight()-1)/32;
		//	if (bigX<20 && bigYb<20 && bigYt>=0)
		if (   (level.materialAt(bigX,bigYt,room).Passable(this) == false)
				|| (level.materialAt(bigX,bigYb,room).Passable(this) == false) )
		{
			automove=0;
			int newDist = bigX*28 - getWidth()- x;
			x += newDist;
			ItemEffectsMaterials();
			return;
		}
		x=x+dist;
		if (x>559)
		{
			if (room.getRightRoom(this) != null)
			{ // change Rooms
				x=x-560;
				SetRoom(room.getRightRoom(this));
			}
			else if (this==level.player && room.portalItem != null)
			{ // Exit item, GameCursor only
				Dimension d = room.portalItem.GetXY();
				x = d.width + (room.portalItem.width - width)/2;
				y = d.height + (room.portalItem.height - height)/2;
				SetRoom(room.portalItem.room);
				MoveRight(dist);
			}
			else
			{ // stop at Right
				x-=560;
				automove=0;
			}
		}
		ItemEffectsMaterials();
	}

	public void MoveUp(boolean nudge) 
	{
		int dist = 32;
		if (nudge) dist = 2;
		MoveUp(dist);
	}

	public void MoveDown(boolean nudge) 
	{
		int dist = 32;
		if (nudge) dist = 2;
		MoveDown(dist);
	}

	public void MoveLeft(boolean nudge) 
	{
		int dist = 28;
		if (nudge) dist = 2;
		MoveLeft(dist);
	}

	public void MoveRight(boolean nudge) 
	{
		int dist = 28;
		if (nudge) dist = 2;
		MoveRight(dist);
	}

	public void Animate() 
	{
		if (automove==1 && room == null)
			automove=0;
		if (automove==1)
		{
			int dx = autoX - x;
			int dy = autoY - y;
			if (dx==0 && dy==0) automove=0;
			if (dx<-28) dx =-28;
			if (dx>28) dx=28;
			if (dy<-32) dy=-32;
			if (dy>32) dy=32;
			if (dx>0) MoveRight(dx);
			if (dx<0) MoveLeft(-dx);
			if (dy>0) MoveDown(dy);
			if (dy<0) MoveUp(-dy);
		}
		if (automove==2)
		{
			if (autoX>0) MoveRight(autoX);
			if (autoX<0) MoveLeft(-autoX);
			if (autoY>0) MoveDown(autoY);
			if (autoY<0) MoveUp(-autoY);
		}
	}

	public void Decorate() 
	{
	}

	public void GenerateIcons() 
	{
		// This is where the icons[] array is filled with ImageIcons, and
		// the ImageIcons are painted. Depending on the Item, this can be
		// done either once during initialization, or once per Animation
		// phase.
	}

	public boolean CanBePickedUp(Item i) 
	{
		// Returns True if THIS Item can be picked up by Item i.
		return grabbable;
	}

	private void ItemEffectsMaterials() 
	{
		// called after every Move() function
		// 
		// Checks the materials touched by this item, and calls their
		// Material.TouchedByItem(Item)

		if (room == null) return;

		Dimension d = GetXY();

		int bigXl = (d.width)/28;
		int bigXr = (d.width+width-1)/28;
		int bigYt = (d.height)/32;
		int bigYb = (d.height+height-1)/32;

		if (bigXr>19) bigXr=19;
		if (bigYb>11) bigYb=11;

		for (int a=bigYt; a<=bigYb; a++)
			for (int b=bigXl; b<=bigXr; b++)
				if (a>=0 && a<12 && b>=0 &&b<20)
					room.MaterialArray[a][b].TouchedByItem(this);

		if (carrying != null)
			carrying.ItemEffectsMaterials();


	}

	public Dimension GetXY() 
	{
		// Recursively goes up the carrying tree to figure out the XY
		// coordinates of an item.

		if (carriedBy != null)
		{
			Dimension d = carriedBy.GetXY();
			d.width += x;
			d.height += y;
			return d;
		}
		else
			return new Dimension(x,y);     
	}

	public void Draw(Graphics g, JPanel jp) 
	{
		Dimension d = GetXY();
		if (currentIcon != null)
			g.drawImage(currentIcon, d.width-orgX, d.height-orgY, jp);
		else
			System.out.println("Cannot draw " + getClass());
		if (outline != null)
		{
			g.setColor(outline);
			g.drawRect(d.width,d.height, width+1, height+1);
			g.drawRect(d.width+1,d.height+1, width-1, height-1);
			outline=null;
		}
	}

	public void Draw(Graphics g, int X, int Y, JPanel jp) 
	{
		g.drawImage(currentIcon, X - orgX, Y - orgY, jp);
	}

	public boolean Overlaps(Item testItem) 
	{
		boolean overlap = false;
		if (this!=testItem && this.room == testItem.room)
		{
			overlap = true;
			Dimension d1 = GetXY();
			Dimension d2 = testItem.GetXY();
			if (this.carrying == testItem) {overlap=false;}
			if (this == testItem.carrying) {overlap=false;}
			if (d1.width + this.width < d2.width) {overlap=false;}
			if (d2.width + testItem.width < d1.width) {overlap=false;}
			if (d1.height + this.height < d2.height) {overlap=false;}
			if (d2.height + testItem.height < d1.height) {overlap=false;}
		}
		return overlap;
	}

	public boolean RightEnterOverlap(Item item) 
	{
		boolean result = true;
		if (leftPortal!= null)
		{
			if (item.x < x + leftPortal.x) result = false;
			if (item.x > x + leftPortal.x + leftPortal.width) result = false;
			if (item.y < y + leftPortal.y) result = false;
			if (item.y > y + leftPortal.y + leftPortal.height) result = false;
		}
		else
			result = false;
		if (OverWall()) result=false;
		return result;
	}

	public boolean DownEnterOverlap(Item item) 
	{
		boolean result = true;
		if (upPortal!=null)
		{
			if (item.x < x + upPortal.x) result = false;
			if (item.x > x + upPortal.x + upPortal.width) result = false;
			if (item.y < y + upPortal.y) result = false;
			if (item.y > y + upPortal.y + upPortal.height) result = false;
		}
		else
			result = false;
		if (OverWall()) result=false;
		return result;	  
	}

	public boolean LeftEnterOverlap(Item item) 
	{
		boolean result = true;
		if (leftPortal!=null)
		{
			if (item.x < x + rightPortal.x) result = false;
			if (item.x > x + rightPortal.x + rightPortal.width) result = false;
			if (item.y < y + rightPortal.y) result = false;
			if (item.y > y + rightPortal.y + rightPortal.height) result = false;
		}
		else
			result = false;
		if (OverWall()) result=false;
		return result;
	}

	public boolean UpEnterOverlap(Item item) 
	{
		boolean result = true;
		if (downPortal!=null)
		{
			if (item.x < x + downPortal.x) result = false;
			if (item.x > x + downPortal.x + downPortal.width) result = false;
			if (item.y < y + downPortal.y) result = false;
			if (item.y > y + downPortal.y + downPortal.height) result = false;
		}
		else
			result = false;
		if (OverWall()) result=false;
		return result;	  
	}

	public boolean isDevice() 
	{
		return false;
	}

	public Object clone() 
	{
		Object newObject = null;
		try
		{
			newObject = super.clone();
		}
		catch (CloneNotSupportedException e) {}
		//	if (newObject instanceof Device)
		//	  {
		//	     Device newDevice = (Device) newObject;
		//	     newDevice.ports = null;
		//	     newDevice.GenerateIcons();
		//	  }
		return newObject;
	}

	public void Erase() 
	{
		carrying = null;
		carriedBy = null;
		room = null;
		currentIcon=null;
		icons = null;
		InternalRoom = null;
	}

	public boolean OverWall() 
	{
		Dimension d = GetXY();
		int bigXL = (d.width+width/2-14)/28;
		int bigXR = (d.width+width/2+14)/28;
		int bigYT = (d.height+height/2-16)/32;
		int bigYB = (d.height+height/2+16)/32;
		if (bigXR>19) bigXR=19;
		if (bigYB>11) bigYB=11;
		boolean flag = false;
		for (int Y=bigYT; Y<=bigYB; Y++)
			for (int X=bigXL; X<=bigXR; X++)
				if (!room.MaterialArray[Y][X].passable)
					flag=true;
		return flag;
	}

}