// tjhCell.java

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

import tjh2dVector;
import tjhGene;
import tjhNeuron;

/** Encapsulates a cell in our pseudo-biological simulation. The cell's properties include a position, a reference
    to its parent (if any) and a list of children (if any). This is a tree structure. */

public class tjhCell extends Object
{
	//-------------------------------------------------------------------------------
	// static constants
	//-------------------------------------------------------------------------------

	/** the radius of the cells, fixed for now at least */
	protected final static float RADIUS=6.0F;

	/** the maximum angular momentum of each cell in degrees */
	protected final static float ANGULAR_MOMENTUM=5.0F;

	/** the distance within which cells can sense each other */
	protected final static float SIGHT_DIST=RADIUS*6;

	/** do we want the cells to use their brains? */
	protected final static boolean USE_BRAINS=true;

	//-------------------------------------------------------------------------------
	// protected data
	//-------------------------------------------------------------------------------

	/** the current location of the cell */
	protected tjh2dVector location;

	/** a reference to the parent of the cell (if any) */
	protected tjhCell parent;

	/** a reference to the owning host creature */
	protected tjhCreature host_creature;

	/** stores whether this cell has a parent, or is the root cell for this creature */
	protected boolean has_parent;

	/** a list of the cells that are children of this cell */
	protected Vector subnodes;

	/** stores the type of the cell, determines its interactions and how it is drawn */
	protected int type;

	/** the current angular momentum of the cell (in degrees) */
	protected float angular_momentum;

	/** the cell's brains (they're a bit thick at the moment) */
	protected tjhNeuron neuron;

	/** stores whether the cell has seen a red enemy cell nearby */
	protected boolean seen_red;

	/** stores whether the cell has seen a green enemy cell nearby */
	protected boolean seen_green;

	//-------------------------------------------------------------------------------
	// private data
	//-------------------------------------------------------------------------------

	/** internal flag, no point moving after death (makes bucketing easier) */
	private boolean been_killed;

	//------------------------------------------------------------------------------
	// public methods
	//-------------------------------------------------------------------------------

	/** default constructor */
	public tjhCell()
	{

		location = new tjh2dVector();
		subnodes = new Vector();
		has_parent = false;

		angular_momentum = RandomAngularMomentum();

		type=tjhGene.GREEN;

		neuron = new tjhNeuron();
	}

	//--------------------------------------------------------------------------------
	/** draws the cell (recurses to draw its daughter cells too) */
	public void Draw(Graphics g)
	{
		g.setColor(type==tjhGene.RED?Color.red:(has_parent?Color.green:Color.magenta));
		g.drawOval((int)(location.x-RADIUS),(int)(location.y-RADIUS),
			(int)RADIUS*2,(int)RADIUS*2);

		tjhCell cell;
		for(int i=0;i<subnodes.size();i++)
		{
			cell = ((tjhCell)subnodes.elementAt(i));
			g.setColor(Color.gray);
			g.drawLine((int)location.x,(int)location.y,(int)cell.location.x,(int)cell.location.y);
			cell.Draw(g); // recurses
		}
	}

	//-------------------------------------------------------------------------------
	// protected methods
	//-------------------------------------------------------------------------------

	/** top-level call to instantiate a tree of cells from the given genome. Makes a note of the host creature 
	    and adds all new cells to the global buckets structure for global collision detection */
	protected void Instantiate(tjhGene genome,tjhCreature host,tjhBuckets buckets,tjh2dVector limit)
	{
		// find a clear space
		int attempts=0;
		do {
			location.x = RADIUS + (float)Math.random()*(limit.x-1.0F-RADIUS*2.0F);
			location.y = RADIUS + (float)Math.random()*(limit.y-1.0F-RADIUS*2.0F);
		} while(attempts++<30 && buckets.CollidesWithAny(location,RADIUS*2));

		// proceed only if we found somewhere free
		if(attempts>=30) return;

		type=genome.type;
		host_creature=host;
		buckets.PutCell(this);

		InstantiateChildren(genome,host,buckets,limit); // (recurses)
	}

	//--------------------------------------------------------------------------------
	/** recurses down to instantiate all mid-level and leaf-level nodes in the tree of cells that is being created */
	protected void InstantiateChildren(tjhGene genome,tjhCreature host,tjhBuckets buckets,tjh2dVector limit)
	{
		// add the subnodes of other as new subnodes of this cell
		tjhGene gene;
		for(int i=0;i<genome.subnodes.size();i++)
		{
			gene = (tjhGene)genome.subnodes.elementAt(i);

			// create if the space is clear
			tjh2dVector loc;
			int attempts=0;
			do {
				loc = tjh2dVector.sum(location,tjh2dVector.mult(tjh2dVector.Cartesian(RandomAngle()),RADIUS*2));
			} while(attempts++<5 && (!InArea(loc,limit) || buckets.CollidesWithAny(loc,RADIUS*2)));

			// proceed only if we found somewhere free
			if(attempts>=5) continue;

			tjhCell new_cell = new tjhCell();
			new_cell.location = loc;
			new_cell.type = gene.type;
			new_cell.parent = this;
			new_cell.has_parent = true;
			new_cell.host_creature = host;
			subnodes.addElement(new_cell);
			buckets.PutCell(new_cell);

			// recurse to copy further children
			new_cell.InstantiateChildren(gene,host,buckets,limit);
		}
	}

	//--------------------------------------------------------------------------------
	/** this cell has been killed, ask it to tidy itself away */
	protected void Killed(tjhBuckets buckets)
	{
		// remove ourself from the parent's list of subnodes
		if(has_parent)
		{
			parent.subnodes.removeElement(this);
		}
		else
		{
			// we're a root cell, need to flag our death outside 
			host_creature.has_died=true;
		}
		// remove ourself and our children from the global list of cells
		RemoveAllFromGlobalList(buckets);
	}

	//--------------------------------------------------------------------------------
	/** recurses down to ask all children to remove themselves from the global buckets structure */
	protected void RemoveAllFromGlobalList(tjhBuckets buckets)
	{
		// remove ourself
		been_killed=true;
		buckets.RemoveCell(this);
		// remove all our children (recurses)
		for(int i=0;i<subnodes.size();i++)
			((tjhCell)subnodes.elementAt(i)).RemoveAllFromGlobalList(buckets);
	}

	//--------------------------------------------------------------------------------
	/** a move request, the cell will move as requested only if able to */
	protected boolean MoveIfCan(tjh2dVector delta,tjh2dVector limit,tjhBuckets buckets)
	{
		Vector deaths = new Vector(); // none yet...
		if(CanMoveBy(delta,limit,buckets,this,deaths))
		{
			// delete the cells that were killed
			for(int i=0;i<deaths.size();i++)
				((tjhCell)deaths.elementAt(i)).Killed(buckets);
			// move ourselves
			MoveBy(delta,buckets);
			// move was successful
			return true;
		}
		else 
		{
			// move was unsuccessful
			return false;
		}
	}

	//--------------------------------------------------------------------------------
	/** detect any collisions with other cells that the requested move would cause */
	protected boolean CanMoveBy(tjh2dVector delta,tjh2dVector limit,tjhBuckets buckets,
		tjhCell asker,Vector deaths)
	{
		// compute our proposed location
		tjh2dVector prop_loc = tjh2dVector.sum(location,delta);

		// will we collide with any other cells? (or the wall?)
		if(!CanMoveTo(prop_loc,limit,buckets,asker,deaths))
			return false;

		// OK, will any of our children collide with any of the other cells?
		for(int i=0;i<subnodes.size();i++)
			if(!((tjhCell)subnodes.elementAt(i)).CanMoveBy(delta,limit,buckets,asker,deaths))
				return false;

		// we're all clear
		return true;
	}

	//--------------------------------------------------------------------------------
	/** each cell moves about its parent axis (as long as no collision is caused) */
	protected void MoveArms(Graphics g,tjhBuckets buckets,tjh2dVector limit)
	{
		// ask all the subnode cells to move themselves
		for(int i=0;i<subnodes.size();i++)
			((tjhCell)subnodes.elementAt(i)).MoveArms(g,buckets,limit);
		// rotate on our parent's axis (if we have one) based on input and brain
		if(has_parent)
		{
			// decide how to move (left/right) based on sensed nearby cells
			StimulusResponse(g,buckets); // (might change angular_momentum)

			if(!RotateIfCan(parent.location,angular_momentum,limit,buckets))
			{
				// something blocked, reset the angular momentum
				angular_momentum = RandomAngularMomentum();
			}
		}
	}
	//--------------------------------------------------------------------------------
	/** search locally for enemy cells, store in seen_red and seen_green */
	/*protected void DetectEnemies(tjhBuckets buckets)
	{
		seen_red = seen_green = false; // until proved wrong

		Vector within_sight = buckets.GetAllWithin(location,SIGHT_DIST);
		for(int found=0;found<within_sight.size();found++)
		{
			// enemy cell within sight!
			tjhCell cell = (tjhCell)within_sight.elementAt(found);

			if(cell.type==tjhGene.GREEN) 
				seen_green=true;
			else if(cell.type==tjhGene.RED) 
				seen_red=true;
		}
	}*/

	//--------------------------------------------------------------------------------
	/** if the neurons are active, reset the angular momentum in response to the nearby cells,
	    otherwise does nothing */
	protected void StimulusResponse(Graphics g,tjhBuckets buckets)
	{
		if(USE_BRAINS)
		{
			Vector within_sight = buckets.GetAllWithin(location,SIGHT_DIST);
			int found = NearestVisible(within_sight);
			if(found!=-1)
			{
				// enemy cell within sight!
				tjhCell cell = (tjhCell)within_sight.elementAt(found);
				// was the cell to the left or right?
				int input[] = new int[tjhNeuron.N_INPUTS];
				for(int j=0;j<tjhNeuron.N_INPUTS;j++) input[j]=0;
				tjh2dVector to_us = tjh2dVector.minus(location,parent.location).Normalize();
				tjh2dVector to_other = tjh2dVector.minus(cell.location,location).Normalize();
				tjh2dVector our_right = to_us.Perp();
				float dot = tjh2dVector.DotProduct(our_right,to_other);
				if(dot<0.0F)
				{
					// found something to the left
					if(cell.type==tjhGene.GREEN) 
						input[0]=1;
					else if(cell.type==tjhGene.RED) 
						input[1]=1;
				}
				else
				{
					// found something to the right
					if(cell.type==tjhGene.GREEN) 
						input[2]=1;
					else if(cell.type==tjhGene.RED) 
						input[3]=1;
				}

				// DEBUG indicate detection with a line
				//g.setColor(Color.orange);
				//g.drawLine((int)location.x,(int)location.y,(int)cell.location.x,(int)cell.location.y);

				// decide what to do on the basis of this detection
				int output = neuron.GetOutput(input);
				if(output!=0)
				{
					angular_momentum = Math.abs(RandomAngularMomentum())*(float)output;

					// DEBUG indicate direction of rotation
					g.setColor(Color.blue);
					g.drawLine((int)location.x,(int)location.y,
						(int)(location.x+our_right.x*5*output),(int)(location.y+our_right.y*5*output));
				}
			}
		}
	}

	//--------------------------------------------------------------------------------
	/** returns the index (in the list within_sight) of the nearest enemy cell */
	protected int NearestVisible(Vector within_sight)
	{
		tjhCell cell;
		int iFound=-1;
		float dist,closest=Float.MAX_VALUE;
		for(int i=0;i<within_sight.size();i++)
		{
			cell = (tjhCell)within_sight.elementAt(i);
			if(cell.host_creature != host_creature)
			{
				// cell is within sight and an enemy, is closest?
				dist = tjh2dVector.minus(location,cell.location).Length();
				if(dist<SIGHT_DIST && dist<closest)
				{
					closest=dist;
					iFound=i;
				}
			}
		}
		return iFound;
	}

	//--------------------------------------------------------------------------------
	/** a rotation request, the cell will rotate only if no collision is caused */
	protected boolean RotateIfCan(tjh2dVector centre,float delta,tjh2dVector limit,tjhBuckets buckets)
	{
		Vector deaths = new Vector(); // none yet...
		// rotate if can otherwise change direction
		if(CanRotate(centre,delta,limit,buckets,this,deaths))
		{
			// delete the cells that were killed
			for(int i=0;i<deaths.size();i++)
				((tjhCell)deaths.elementAt(i)).Killed(buckets);
			// apply the proposed rotation
			Rotate(centre,delta,buckets);
			// rotation was successful
			return true;
		}
		else
		{
			// rotation was not successful
			return false;
		}
	}

	//--------------------------------------------------------------------------------
	/** will the requested rotation cause a collision? */
	protected boolean CanRotate(tjh2dVector centre,float delta,tjh2dVector limit,tjhBuckets buckets,tjhCell asker,Vector deaths)
	{
		// compute our proposed location
		tjh2dVector prop_loc = new tjh2dVector();
		prop_loc.x = location.x;
		prop_loc.y = location.y;
		prop_loc.RotateAround(centre,delta);

		// will we collide with any other cells? (or the wall?)
		if(!CanMoveTo(prop_loc,limit,buckets,asker,deaths))
			return false;

		// OK, will any of our children collide with any of the other cells?
		for(int i=0;i<subnodes.size();i++)
			if(!((tjhCell)subnodes.elementAt(i)).CanRotate(centre,delta,limit,buckets,asker,deaths))
				return false;

		// we're all clear
		return true;
	}
	
	//--------------------------------------------------------------------------------
	/** collision detection/resolution check for a *single* cell, doesn't recurse */
	protected boolean CanMoveTo(tjh2dVector prop_loc,tjh2dVector limit,tjhBuckets buckets,tjhCell asker,Vector deaths)
	{
		// would we be off the legal area if we moved to the proposed location?
		if(!InArea(prop_loc,limit))
			return false;

		// deal with any collisions that would occur
		tjhCell cell;
		Vector collisions = buckets.GetAllWithin(prop_loc,RADIUS*2.0F-0.01F); // math tolerance
		for(int i=0;i<collisions.size();i++)
		{
			cell = (tjhCell)collisions.elementAt(i);
			// if it's in our own branch then the overlapped cell will be moved too, not an obstacle
			if(!asker.IsOurChild(cell))
			{
				// check that overlapping cell isn't part of the same creature as us
				if(host_creature==cell.host_creature)
				{
					// overlap is not permitted within the creature, whatever the cell types
					return false;
				}
				else
				{
					// detected collision with the cell of another creature
					if(cell.type==tjhGene.GREEN && type==tjhGene.RED)
					{
						// we eat them!
						deaths.addElement(cell);
						// (no overlap flagged)
					}
					else if(type==tjhGene.GREEN && cell.type==tjhGene.RED)
					{
						// they eat us! :(
						deaths.addElement(this);
						// (no overlap flagged)
					}
					else 
					{
						// was pink bounce?
						if(!has_parent && !cell.has_parent)
							host_creature.pink_bounce=true;

						// overlap is not permitted
						return false;
					}
				}
			}
		}

		// no obstacle found
		return true;

		// (notice that this function doesn't recurse, is called from CanMoveBy and CanRotateBy which do)
	}

	//--------------------------------------------------------------------------------
	/** is the specified cell below us in the tree? */
	protected boolean IsOurChild(tjhCell child)
	{
		if(child == this) return true;
		else if(!child.has_parent) return false;
		else return IsOurChild(child.parent);
	}

	//--------------------------------------------------------------------------------
	/** all checks have been made, just move the cells */
	protected void MoveBy(tjh2dVector delta,tjhBuckets buckets)
	{
		if(!been_killed)
		{
			// remove current bucket marker
			buckets.RemoveCell(this);
			// change our location
			location = tjh2dVector.sum(location,delta);
			// add our current bucket marker
			buckets.PutCell(this);
			// recurse down
			for(int i=0;i<subnodes.size();i++)
				((tjhCell)subnodes.elementAt(i)).MoveBy(delta,buckets);
		}
	}

	//--------------------------------------------------------------------------------
	/** all checks have been made, just rotate the cell */
	protected void Rotate(tjh2dVector centre,float delta,tjhBuckets buckets)
	{
		if(!been_killed)
		{
			// remove current bucket marker
			buckets.RemoveCell(this);
			// change our location
			location.RotateAround(centre,delta);
			// add our current bucket marker
			buckets.PutCell(this);
			// recurse down
			for(int i=0;i<subnodes.size();i++)
				((tjhCell)subnodes.elementAt(i)).Rotate(centre,delta,buckets);
		}
	}

	//--------------------------------------------------------------------------------
	/** is the point loc within the area of the simulation? */
	protected boolean InArea(tjh2dVector loc,tjh2dVector limit)
	{
		return loc.x>RADIUS && loc.y>RADIUS && loc.x<limit.x-1-RADIUS && loc.y<limit.y-1-RADIUS;
	}

	//--------------------------------------------------------------------------------
	/** is the point loc closer to the cell them than the distance d? */
	protected boolean CloserThan(tjh2dVector loc,tjhCell them,float d)
	{
		return (them.location.x-loc.x)*(them.location.x-loc.x) + 
			(them.location.y-loc.y)*(them.location.y-loc.y) < d*d;
	}

	//--------------------------------------------------------------------------------
	/** pick an angular momentum at random */
	protected float RandomAngularMomentum()
	{
		// want a value less than ANGULAR_MOMENTUM but greater than one
		// or the negation of this
		return ((float)Math.random()*(ANGULAR_MOMENTUM-1.0F)+1.0F) * 
			(Math.random()>0.5?-1.0F:1.0F);
	}

	//--------------------------------------------------------------------------------
	/** return a random angle between 0 and 360 degrees */
	protected float RandomAngle()
	{
		return (float)Math.random()*360.0F;
	}
}