#ifndef FIELD_H_
#define FIELD_H_

#include <iostream>
#include <vector>
#include <map>



using namespace std;

class Agent {
 public:
  enum Action {STAY, DIE, MOVE, CLONE};
  // this defines a new type which can have only above possible values
  // (see p. 141 in the textbook for details)
  // to access the type or values you have to use scope resolution operator
  // (for instance, Agent::Action a=Agent::STAY)
  enum Dir {E, NE, N, NW, W, SW, S, SE};
  Agent() {}
  virtual ~Agent() {}
  virtual Agent *clone() const =0;
  virtual long priority() const =0;
  virtual char state() const =0;
  typedef pair<Action,vector<Dir> > Answer; // shortcut
  virtual Answer act(const vector<char> &surrounding,
                     const vector<char>& myposition,long level) =0;
};

class Point {
 public:
  int x,y;
  Point(int ix=0,int iy=0) : x(ix), y(iy) {}
	bool operator==(const Point &p) const { return (x==p.x  && y ==p.y); }
	bool operator <(const Point &p) const { return (x<p.x || (x==p.x) && y<p.y); }
};

class Point_less {
	public:
  	bool operator()(const Point& p,const Point& q)
	{ return (p.x<q.x || (p.x==q.x) && p.y<q.y); }
	};

ostream& operator<<(ostream& C, const Point &p);

typedef pair<Point,Point> Region;


class Field {

//private interface
 private:

//data structure to hold all cell with corresponding agents sorted by their priority 
map<Point, multimap<long,Agent*> > grid;

long no_agents;
 
//structure used in step()
struct temp_ {
	long level; 
	Point p; 
	Agent *agent; 
	vector<char> mypos; 
	vector<char> surr; 
	} ;

typedef temp_ tmp;

//field size
int sx , sy;
//returns a point corresponding to the direction and point provided.
Point getP (Agent::Dir , Point p);

public:



  // public interface:
  Field(int sizex, int sizey);
  // construct field with no agents of size sizex x sizey
  ~Field(); // call delete on all pointers to agents stored in the field

  // ADDING AGENTS:
  void plant_agent(const Point &p, Agent *a);
  // put agent a to the cell p

  // EXAMINING AGENTS:
  long n_of_agents() const;
  // return the total number of agents currently on the field
  long n_of_agents(const Point &p) const;
  // return the number of agents in the cell p
  const Agent *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

  // REMOVING AGENTS:
  void 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
  void remove_agent(const Point &p);
  // remove all agents from the cell p
  // remember to call delete on the pointer to agent before removing
  void 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)!

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

  // LIFE CYCLE (the main method):
  void step(long n=1);
  // performs n steps of life cycle of the field (described later in details)

  friend ostream & operator<<(ostream &os, const Field &s);
  // print the states of each cell in the region returned by range()
  // (see below)
};
#endif