//CMPT-212, ASSIGNMENT 3    2/2 - Field Source File
//Raymond Kin Hei Lee
//March 23, 2008

#include "field.h"

using namespace std;

Field :: Field(int x, int y) //Constructor
{
	grid.reserve(x*y); //Reserve grid size
	
	vector<Agent*> temp(0); //Create a tempoary vector<Agent*> with zero size
							//to put into our grid
	for(long i=0; i<x*y; i++)
		grid.push_back(temp); //Fill grid with empty vectors, to avoid error

	sizex = x;	//store max grid size
	sizey = y;
}

Field :: ~Field()//Destructor
{	
	for(int j=0; j<sizey; j++)
	{
		for(int i=0; i<sizex; i++)
		{
			for(unsigned long k=0; k<grid.at(sizex*j + i).size(); k++)
			{
				delete grid.at(sizex*j + i).at(k); //Delete each agent within grid
			}
		}
	}
}

long Field :: convert(const Point &p) const //Convert a Point to an integer 
										//that could be understood by our vectors
{
	return (sizex*p.y + p.x);
}

void Field :: sort(const long &point) //Sort the cell from highest to smallest agents
{
	Agent* temp;

	for(unsigned long i=0; i<grid.at(point).size(); i++) 
	{			//For each possible agent within the cell, check who has a larger priority 
		for(unsigned long j=i+1; j<grid.at(point).size(); j++)
		{
			if(grid.at(point).at(i)->priority()<grid.at(point).at(j)->priority()) 
			{ //Found a priority smaller, but further in the index.. swap needed
				temp = grid.at(point).at(i);
				grid.at(point).at(i) = grid.at(point).at(j);
				grid.at(point).at(j) = temp;
			}
		}
	}
}



agentInfo Field :: findInfo(const Point &p) //For a coordinate, find out its agentInfo
{											//agentInfo if s pair of info, <mySurrounding, myPosition>
	agentInfo temp;	
	for(signed int j=1; j>=-1; j--)
	{ //For each coordinate...
		for(signed int i=-1; i<=1; i++)
		{
			if((p.x==0 && i==-1)||(p.x==(sizex-1)&&i==1)
				|| (p.y==0 && j==-1) || (p.y==(sizey-1)&&j==1)) //Off boundary, return '*'
				temp.first.push_back('*');
			else if(grid.at(sizex*(p.y + j) + (p.x+i)).size()==0)
				temp.first.push_back(' ');  //Nothing there, size()=0, return ' '
			else if(!(i==0 && j==0))
				temp.first.push_back(grid.at(sizex*(p.y+j)+(p.x+i)).at(0)->state());
			else
				for(unsigned long i=0; i<grid.at(convert(p)).size(); i++)
				{
					temp.second.push_back(grid.at(convert(p)).at(i)->state());
				}
		}
	}
			
	return temp;
}


vector<Point> Field :: findDirection(Point p, vector<Agent::Dir> dir)
{//Changes the directions (N, NE, S, etc..) that is returned by act() into meaningful Points
	Point temp;
	vector<Point> dirVec; //Vector, since more than one Point is possible...
	
    for(unsigned long i=0; i<dir.size(); i++)
	{
		temp=p;
		switch(dir.at(i))
		{
			case Agent::N:
				temp.y += 1;
				break;
			case Agent::NE:
				temp.x += 1;
				temp.y += 1;
				break;
			case Agent::E:
				temp.x += 1;
				break;
			case Agent::SE:
				temp.x += 1;
				temp.y += -1;
				break;
			case Agent::S:
				temp.y += -1;
				break;
			case Agent::SW:
				temp.x += -1;
				temp.y += -1;
				break;
			case Agent::W:
				temp.x += -1;
				temp.y += 0;
				break;
			case Agent::NW:
				temp.x += -1;
				temp.y += 1;
				break;
			default:
				break;
		}
		dirVec.push_back(temp);
	}
	return dirVec;
}


void Field :: plant_agent(const Point &p, Agent *a)
{
	long point = convert(p);

	if(point < sizex * sizey) //If that point is within the grid...
	{
		grid.at(point).push_back(a); //Add the new Agent* a
		sort(point); //Sort the vector of agents into ascending priorities
	}
}

long Field :: n_of_agents() const
{
	long temp = 0;
	//For every point on the grid, find it's size() (...or number of agents)
	for(long i = 0; i<(sizex * sizey); i++)
		temp += grid.at(i).size();
	
	return temp;
}

long Field :: n_of_agents(const Point &p) const
{ //For a particular point on the grid, find its size()...
	if(convert(p) < sizex * sizey)
		return (long)grid.at(convert(p)).size();
	else
		return 0;
}

const Agent* Field :: get_agent(const Point &p, long i) const
{
	if(convert(p) < sizex * sizey)//if the point is on the grid
	{
		if(i >= 0 && i < n_of_agents(p))
			return grid.at(convert(p)).at(i); //return specified Agent*
	}
	
	return NULL;
}

void Field :: remove_agent(const Point &p, long i)
{
	vector<Agent*>::iterator it;
	if(convert(p) < sizex * sizey)
	{
		if(i >0 || i < n_of_agents(p))
		{
			it = grid.at(convert(p)).begin();
			delete grid.at(convert(p)).at(i); //Delete specified Agent*
			grid.at(convert(p)).erase(it+i); //Remove the deleted Agent* from stack
		}
	}
}

void Field :: remove_agent(const Point &p)
{
	long point = convert(p);
	if(point < sizex * sizey)
	{
		for(long i=grid.at(point).size()-1; i>=0; i--)
		{
			delete grid.at(point).at(i);//Delete
			grid.at(point).pop_back();//Pop the furthest one.. but all will be removed anyway
		}
	}
}

void Field :: remove_agent(const Region &r)
{
	Point temp;
	for(int j=r.first.y; j< r.second.y; j++)
	{
		for(int i=r.first.x; i <r.second.y; i++) 
		{
			temp.x = i;
			temp.y = j;
			remove_agent(temp);	//Calls remove_agent for every point in region		
		}
	}
			
}


char Field :: get_state(const Point &p) const
{
	long point = convert(p);
	if(grid.at(point).size()>0)
		return grid.at(point).at(0)->state(); //Calls state()
	else return ' ';
}

void Field :: step(long n)
{//I followed the Professor's suggestion for this part. All surroundings are first stored,
	//then all agents are placed in the tempGrid according to act() being called by the field
while(n>0)
{
	vector<vector<Agent*>> tempGrid; //tempoary grid for putting new actions
	vector<Agent*> temp123(0);

	for(long i=0; i<sizex*sizey; i++)
			tempGrid.push_back(temp123); //filling up the grid with empty vectors to avoid errors
	
	vector<vector<agentInfo>> agentSurrounding; //Creating a vector for holding agent info
	vector<agentInfo> temp1234(0);				//agentInfo includes mySurrounding, and myPosition

	for(long i=0; i<sizex*sizey; i++)
			agentSurrounding.push_back(temp1234); //filling vector up with garbage
	
	Agent::Answer actResult; //Temp variable for holding the Answer of each act()

	for(long j=0; j<sizey; j++) //first, for all points, all agents, find mySurrounding/myPosition
	{
		for(long i=0; i<sizex; i++)
		{
			Point tempPt(i,j);
			for(unsigned long l=0; l<grid.at(sizex*j + i).size(); l++)
			{//Store all agent Surroundings and Position
				agentSurrounding.at(sizex*j + i).push_back(findInfo(tempPt));  
			}
		}
	}

	for(long j=0; j<sizey; j++)
	{//For all points, all agents, run act() with the agentSurrounding info, then act correspondingly
		for(long i=0; i<sizex; i++)
		{
			Point tempPt(i,j);
			for(unsigned long l=0; l<grid.at(sizex*j + i).size(); l++)
			{
				actResult = grid.at(convert(tempPt)).at(l)->act(agentSurrounding.at(convert(tempPt)).at(l).first, agentSurrounding.at(convert(tempPt)).at(l).second, l);//agentSurrounding.at(convert(tempPt)).at(l).second);
				long point = convert(tempPt);
				vector<Point> tempDir = findDirection(tempPt, actResult.second);
				//breaks directions into something more useful: Points
				switch(actResult.first)
				{//Check which action
					case Agent::STAY:
					{ //Stay in same position. ie, place the same agent on the same spot in tempGrid						
						tempGrid.at(point).push_back(grid.at(point).at(l));
						break;
					}

					case Agent::DIE:
					{//Nothing needs to be placed in the new grid, call delete on agent*
						delete grid.at(point).at(l);
						break;
					}
					
					case Agent::MOVE:
					{//If point is valid, copy the agent to all points stated by direction		
						if(!((tempDir.at(0).x<0 || tempDir.at(0).x>= sizex)
							|| (tempDir.at(0).y<0 || tempDir.at(0).y>= sizey)))
						tempGrid.at(convert(tempDir.at(0))).push_back(grid.at(point).at(l));
						else
							delete grid.at(point).at(l);
						break;
					}
					case Agent::CLONE: 
					{//Similar to MOVE, but create CLONE instead
				
						tempGrid.at(point).push_back(grid.at(point).at(l));

						for(unsigned long k=0; k<tempDir.size(); k++)
						{
							if(!((tempDir.at(k).x<0 || tempDir.at(k).x>= sizex)
								|| (tempDir.at(k).y<0 || tempDir.at(k).y>= sizey)))
							tempGrid.at(convert(tempDir.at(k))).push_back(grid.at(point).at(l)->clone());
						}
						break;
					}
				}				
			}
		}
	}
	
	grid=tempGrid; //Save the info into actual Field
	
	for(long j=0; j<sizey; j++)
	{
		for(long i=0; i<sizex; i++)
		{
			sort(sizex*j + i); //Sorting by priorities
		}
	}
	
	n-=1; //If n>1 to begin, then keep going
}
}

ostream & operator<<(ostream &os, const Field &s)
{
	for(long j=s.sizey-1; j>=0; j--)
	{//For every point on the grid, starting from top left corner...
	  for(long i=0; i<s.sizex; i++)
	  {
		  Point temp(i,j);
		  if(s.n_of_agents(temp)>0)//If there are at least one agent there...
		  cout<<s.grid.at(s.sizex*j + i).at(0)->state();//print the one with highest priority
		  else cout << " "; //If no agents there, print ' '
	  }
	  cout << endl;
	}
return os;
}

ostream& operator<<(ostream& C, const Point &p)
{
  C <<"("<<p.x<<","<<p.y<<")";
  return C;
}