#include "field.h"
#include <Vector>
#include <algorithm>



//MY SORT function
bool cellSort(Agent *p1, Agent *p2){
	return (*p1).priority()>(*p2).priority();
}//end cellsort


//HELPER FUNCTIONS

Point Field::newLocation(int cur_X, int cur_Y, int moveTo){



	Point result;
	if(moveTo == 0){//East
		result = Point(cur_X+1, cur_Y);
	}//end if
	else if(moveTo == 1){//NE
		result = Point(cur_X+1, cur_Y+1);
	}//end else if
	else if(moveTo == 2){//North
		result = Point(cur_X, cur_Y+1);
	}//end else if
	else if(moveTo == 3){//NW
		result = Point(cur_X-1, cur_Y+1);
	}//end else if
	else if(moveTo == 4){//West
		result = Point(cur_X-1, cur_Y);
	}//end else if
	else if(moveTo == 5){//SW
		result = Point(cur_X-1, cur_Y-1);
	}//end else if
	else if(moveTo == 6){//South
		result = Point(cur_X, cur_Y-1);
	}//end else if
	else if(moveTo == 7){//SE
		result = Point(cur_X+1, cur_Y-1);
	}//end else if
	else{
		//error
		//cout << "Error moving to SAME place" <<endl;
		result = Point(cur_X, cur_Y);
	}
	return result;
}//end newLocation


vector<char> Field::getSurrounding(int x, int y){
	//returns state of hight priority agent in each cell if no agent returns ' ' 
	//if cell out of bounds return '*'
	//0 1 2
	//3   4
	//5 6 7

	//using Dir
	//3 2 1
	//4   0
	//5 6 7
	vector<char> result(8);
	for(int z=0; z<8; z++){

		if(z==0){
			if(isInBound(newLocation(x,y, 3))){
				Point pT = newLocation(x,y, 3);
				if(grid[pT.x][pT.y].size()==0){//can't call state on an empty space
					result[0]= ' '; 
				}//end if
				else{
					result[0] = grid[pT.x][pT.y][0]->state();
				}
			}//end if
			else{
				//must be out-of-bounds
				result[0] = '*';
			}//end else	
		}//end if
		else if(z==1){
			if(isInBound(newLocation(x,y, 2))){
				Point pT = newLocation(x,y, 2);
				if(grid[pT.x][pT.y].size()==0){//can't call state on an empty space
					result[1]= ' '; 
				}//end if
				else{
					result[1] = grid[pT.x][pT.y][0]->state();
				}
			}//end if
			else{
				//must be out-of-bounds
				result[1] = '*';
			}//end else	
		}//end else if
		else if(z==2){
			if(isInBound(newLocation(x,y, 1))){
				Point pT = newLocation(x,y, 1);
				if(grid[pT.x][pT.y].size()==0){//can't call state on an empty space
					result[2]= ' '; 
				}//end if
				else{
					result[2] = grid[pT.x][pT.y][0]->state();
				}
			}//end if
			else{
				//must be out-of-bounds
				result[2] = '*';
			}//end else	
		}//end else if
		else if(z==3){
			if(isInBound(newLocation(x,y, 4))){
				Point pT = newLocation(x,y, 4);
				if(grid[pT.x][pT.y].size()==0){//can't call state on an empty space
					result[3]= ' '; 
				}//end if
				else{
					result[3] = grid[pT.x][pT.y][0]->state();
				}
			}//end if
			else{
				//must be out-of-bounds
				result[3] = '*';
			}//end else	
		}//end else if
		else if(z==4){
			if(isInBound(newLocation(x,y, 0))){
				Point pT = newLocation(x,y, 0);
				if(grid[pT.x][pT.y].size()==0){//can't call state on an empty space
					result[4]= ' '; 
				}//end if
				else{
					result[4] = grid[pT.x][pT.y][0]->state();
				}
			}//end if
			else{
				//must be out-of-bounds
				result[4] = '*';
			}//end else	
		}//end else if
		else if(z==5){
			if(isInBound(newLocation(x,y, 5))){
				Point pT = newLocation(x,y, 5);
				if(grid[pT.x][pT.y].size()==0){//can't call state on an empty space
					result[5]= ' '; 
				}//end if
				else{
					result[5] = grid[pT.x][pT.y][0]->state();
				}
			}//end if
			else{
				//must be out-of-bounds
				result[5] = '*';
			}//end else	
		}//end else if
		else if(z==6){
			if(isInBound(newLocation(x,y, 6))){
				Point pT = newLocation(x,y, 6);
				if(grid[pT.x][pT.y].size()==0){//can't call state on an empty space
					result[6]= ' '; 
				}//end if
				else{
					result[6] = grid[pT.x][pT.y][0]->state();
				}
			}//end if
			else{
				//must be out-of-bounds
				result[6] = '*';
			}//end else	
		}//end else if
		else{
			if(isInBound(newLocation(x,y, 7))){
				Point pT = newLocation(x,y, 7);
				if(grid[pT.x][pT.y].size()==0){//can't call state on an empty space
					result[7]= ' '; 
				}//end if
				else{
					result[7] = grid[pT.x][pT.y][0]->state();
				}
			}//end if
			else{
				//must be out-of-bounds
				result[7] = '*';
			}//end else	

		}//end else

	}//end for


	return result;

}//end getSurrounding

vector<char> Field::getLocalAgents(int x, int y){
	//returns the states of all agents in the cell in order of priority
	vector<char> result(grid[x][y].size());
	for(int z=0; z<grid[x][y].size(); z++){
		result[z] = grid[x][y][z]->state();

	}//end for

	return result;

}//end getLocalAgents


bool Field::isInBound(Point &p){

	if(p.x>=0 && p.x<gridSize.x){
		if(p.y>=0 && p.y<gridSize.y){

			return true;
		}//end if
	}//end if

	return false;
}//end check bound

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

ostream& operator<<(ostream& C, const Cell &p)
{
	if(p.size()==0){
		C<<" ";
	}//end if
	else{
		C <<(*p[0]).state();

	}//end else

	return C;
}
ostream& operator<<(ostream& C, const Field &p)
{
	for(int y=p.gridSize.y-1; y>=0; y--){
		for(int x=0; x<p.gridSize.x; x++){
			C << p.get_state(Point(x,y));

		}//end for
		C<< endl;
	}//end for

	return C;
}




Field::Field(int sizex, int sizey):grid(sizex, vector<Cell>(sizey)),gridSize(sizex, sizey){


	// construct field with no agents of size sizex x sizey

}//end field
Field::~Field(){ // call delete on all pointers to agents stored in the field

	//loop through and delete all agents simalar to print code ecept deleting
	for(int y=gridSize.y-1; y>=0; y--){
		for(int x=0; x<gridSize.x; x++){
			for(int zz=0; zz<grid[x][y].size(); zz++){
				delete grid[x][y][zz];
			}//end for
		}//end for
	}//end for

}//end ~Field

const Agent* Field::get_agent(const Point &p, long i) const{
	// return a pointer to the i-th agent in the cell p
	// if i<0 or i>=n_of_agents(p) return NULL pointer

	if( i<0 || i>=grid[p.x][p.y].size() ){
		return NULL;
		//do noting
	}//end if
	else{
		return grid[p.x][p.y][i];
	}//end else

}//end get_agent

char Field::get_state(const Point &p) const{
	// returns the state of agent with highest priority in cell p
	// or ' ' if there is no agent

	if(grid[p.x][p.y].size()==0){
		return ' ';
	}//end if
	//assumn Cell is sorted by priority
	return grid[p.x][p.y][0]->state();

}//end get state

long Field::n_of_agents() const{
	// return the total number of agents currently on the field

	long counter = 0;
	for(int y=0; y<gridSize.y; y++){
		for(int x=0; x<gridSize.x; x++){
			for(int zz=0; zz<grid[x][y].size(); zz++){
				//add to counter
				counter++;
			}//end for
		}//end for
	}//end for

	return counter;
}//end n_of_agents

long Field::n_of_agents(const Point &p) const{
	// return the number of agents in the cell p
	long counter = 0;
	for(int z=0; z<grid[p.x][p.y].size(); z++){
		//add to counter
		counter++;
	}//end for
	return counter;
}//end n_of_agents()

void Field::plant_agent(const Point &p, Agent *a){
	// put agent a to the cell p
	grid[p.x][p.y].push_back(a);
	//now sort by priority
	sort(grid[p.x][p.y].begin(), grid[p.x][p.y].end(), cellSort);
}//end plant_agent

void Field::remove_agent(const Point &p, long i){
	// if i>=0 or i<n_of_agents(p) remove the agent (otherwise do nothing)
	// remember to call delete on the pointer to agent before removing
	if(i>=0 && i<n_of_agents(p)){

		Cell temp;
		//add agents to temp skipping the one to be deleted
		//this for loop maintains the order so no need to resort
		for(int z=0; z<grid[p.x][p.y].size(); z++){
			if(z!=i)
				temp.push_back(grid[p.x][p.y][z]);
		}//end for
		delete grid[p.x][p.y][i];
		//no need to resort as Cell should already be sorted
		//grid[p.x][p.y] = temp;
		grid[p.x][p.y].clear();
		for(int zz=0; zz<temp.size(); zz++){
			grid[p.x][p.y].push_back(temp[zz]);
		}//end for

	}
	else{
		//outside of delete range
	}

}//remove_agent
void Field::remove_agent(const Point &p){
	// remove all agents from the cell p
	// remember to call delete on the pointer to agent before removing
	for(int z=0; z<grid[p.x][p.y].size(); z++){
		delete grid[p.x][p.y][z];
	}//end for
	grid[p.x][p.y].clear();


}//remove_agent
void Field::remove_agent(const Region &r){
	// remove all agents in the region r
	// remember to call delete on the pointer to agent before removing
	// remember Region(Point(0,0),Point(2,2)) contains only cells
	// (0,0), (0,1), (1,0) and (1,1)!
	int currentX = r.first.x;
	int currentY = r.first.y;
	for(int x=r.first.x; x<r.second.x; x++){
		for(int y=r.first.y; y<r.second.y; y++){
			remove_agent(Point(x,y));

		}//end for
	}//end for


}//end remove_agent

void Field::step(long n){
	// performs n steps of life cycle of the field (described later in details)

	//first int through the field and get needed stuff to call act()
	//then get result(Die,stay, whatever) and do that action it in "altGrid"
	//now delete all agents that where deleted in GRID  !!!IMPORTANT!!!
	//grid = altGrid
	for(int Q=0; Q<n; Q++){
		//create altGrid
		vector<vector<Cell> > ALTgrid(gridSize.x, vector<Cell>(gridSize.y));
		vector<toDelete> to_del;
		vector<ActData> actionData;
		//first int through the field and get needed stuff to call act()
		for(int y=0; y<gridSize.y; y++){
			for(int x=0; x<gridSize.x; x++){
				for(int zz=0; zz<grid[x][y].size(); zz++){


					Agent* AG = grid[x][y][zz];

					vector<char> sur = getSurrounding(x,y);

					vector<char> pis = getLocalAgents(x,y);

					actionData.push_back(ActData(sur,pis, zz, AG, Point(x,y)));




				}//end for
			}//end for
		}//end for

		for(int b=0; b<actionData.size(); b++){
			//then get result(Die,stay, whatever) and do that action it in "altGrid"
			Agent::Action action;
			Agent::Answer ans;
			//	vector<char> sur,pos;
			//	long index;
			//	Agent* AG;
			//	Point cur_loc;
			Point curLocal = actionData[b].cur_loc;
			Agent *AGNT = actionData[b].AG;
			ans = (*(actionData[b].AG)).act(actionData[b].sur, actionData[b].pos, actionData[b].index);
			action = ans.first;

			if(action==0){//STAY  
				//add agent to the altField
				//altField.plant_agent(Point(x,y), AG);
				ALTgrid[curLocal.x][curLocal.y].push_back(AGNT);
			}//end if
			else if(action==1){//DIE
				to_del.push_back(toDelete(curLocal, actionData[b].index));
			}//end else if
			else if(action==2){//MOVE
				//puts agent in it's new location returned by newLocation
				vector<Agent::Dir> dirIn = ans.second;
				//altField.plant_agent(newLocation(x,y, dirIn[0]), AG);
				Point temp = newLocation(curLocal.x,curLocal.y, dirIn[0]);
				ALTgrid[temp.x][temp.y].push_back(AGNT);

			}//end else if
			else if(action==3){//CLONE
				vector<Agent::Dir> dirIn = ans.second;
				//add all the clones to altField

				for(int zzz=0; zzz<dirIn.size(); zzz++){
					//altField.plant_agent(newLocation(x,y, dirIn[zzz]), (*AG).clone());
					Point temp = newLocation(curLocal.x,curLocal.y, dirIn[zzz]);
					if(isInBound(temp))
						ALTgrid[temp.x][temp.y].push_back((*AGNT).clone());
				}//end for
				//now add the orig agent
				ALTgrid[curLocal.x][curLocal.y].push_back(AGNT);
			}//end else if
			else{
				//should never get here
				//cout<<"ERROR -- ERROR -- ERROR -- ERROR -- ERROR --";
			}

		}//end for



		//now delete all agents that where deleted in GRID  !!!IMPORTANT!!!
		for(int z=0; z<to_del.size(); z++){
			//remove_agent(to_del[z].first, to_del[z].second);
			delete grid[to_del[z].first.x][to_del[z].first.y][to_del[z].second];
		}//end for

		//grid = altGrid
		for(int y=0; y<gridSize.y; y++){
			for(int x=0; x<gridSize.x; x++){
				grid[x][y].clear();
				for(int zz=0; zz<ALTgrid[x][y].size(); zz++){
					grid[x][y].push_back(ALTgrid[x][y][zz]);
				}//end for
				//now sort
				sort(grid[x][y].begin(), grid[x][y].end(), cellSort);
			}//end for
		}//end for



		//MEMORY LEAK altField????????????????

	}//end for



}//end STEP