#include <cstdio>
#include <assert.h>
#include <iostream>
#include "../include/types.h"
#include "../include/language.h"
#include "../include/parser.h"
#include "../include/randgen.h"
#include "../include/simulator.h"

using namespace std;

#define panic() assert(0)
#define isMarked(x) ((x)&ALY_MARKER_MASK)

Command* algo[2];
int algosize[2];
int numants[2];
int max_id;
Ant* ants;
Map map;
int step;

inline void getNeighbor(Point & ret, Point cur, char dir)
{
	switch(dir)
	{
		case 0:
			ret.x=cur.x+1;
			ret.y=cur.y;
			break;
		case 1:
			ret.x=cur.x + (cur.y%2 ? 1:0);
			ret.y=cur.y+1;
			break;
		case 2:
			ret.x=cur.x - (cur.y%2 ? 0:1);
			ret.y=cur.y+1;
			break;
		case 3:
			ret.x=cur.x-1;
			ret.y=cur.y;
			break;
		case 4:
			ret.x=cur.x - (cur.y%2 ? 0:1);
			ret.y=cur.y-1;
			break;
		case 5:
			ret.x=cur.x + (cur.y%2 ? 1:0);
			ret.y=cur.y-1;
			break;
		default:
			panic();
	}
	//TODO: check for out-of-bounds
}

inline char turn(char dir,char delta)
{
	return (dir+6+delta)%6;
}

//check is cell at position pos is surrounded by at least 5 ants of color col
boolean surrounded(Point & pos, char col)
{
	char dir,count;
	Point next;
	count=0;
	for(dir=0;dir<6;dir++)
	{
		getNeighbor(next,pos,dir);
		if(map.object[next.x][next.y]==col) count++;
	}
	return (count>=5);
}


void killAnt(Ant & ant)
{
	ant.dead=1;
	map.foodcount[ant.pos.x][ant.pos.y]+=(ant.has_food?4:3);
	if(ant.has_food)
		map.marker[ant.color][ant.pos.x][ant.pos.y]^=foodCarryCode;
	map.object[ant.pos.x][ant.pos.y]=EMPTY;
}

Ant & findAnt(Point & loc)
{
	int i;
	for(i=0;i<max_id;i++)
    //Ants have not developed immortality serum
		if(ants[i].pos.x==loc.x && ants[i].pos.y==loc.y && (!ants[i].dead) )
			return ants[i];
	panic();
}

void setupAnts()
{
	int x,y;
	char col;
	
	max_id=0;
	for(col=0;col<=1;col++)
	{
		numants[col]=0;
		for(y=0;y<map.sizey;y++)
			for(x=0;x<map.sizex;x++)
				if(map.object[x][y]==col)
					numants[col]++;
	}
	ants=new Ant[numants[RED]+numants[BLACK]];
	assert(ants);
	for(y=0;y<map.sizey;y++)
		for(x=0;x<map.sizex;x++)
			if(isColor(map.object[x][y]))
			{
				ants[max_id].id=max_id;
				ants[max_id].pc=0;
				ants[max_id].pos.x=x;
				ants[max_id].pos.y=y;
				ants[max_id].dir=0;
				ants[max_id].color=map.object[x][y];
				ants[max_id].resting=0;
				ants[max_id].has_food=0;
				ants[max_id].dead=0;
				max_id++;
			}
}

void simulate(int nsteps,char doDebug)
{
	int id;
	char col;
	Point next;
	char match; //test flag; used with sense
	
	for(step=0;step<nsteps;step++)
	{
    if (doDebug && SIMDUMP)
    {
      printf("\nAfter round %d...\n",step);
      dumpState(map);
    }
		if(doDebug && SIMSTEP && (step % MODSZ == 0))
    {
      printf("\nStep %d\n",step);
      printMap(map);
      printf("\n\nFOOD TRAILS!\n\n");
      printTrails(map, RED, 0x07 << 3);
      printf("\n\nHOME TRAILS!\n\n");
      printTrails(map, RED, 0x07);
    }
		for(id=0;id<max_id;id++)
		{
			if(ants[id].dead) continue;
			if(ants[id].resting) {ants[id].resting--; continue;}

      if (0 && id == 82)//103)
        cout << "PC: " << ants[id].pc << endl;
      if (0 && ants[id].pc == 187)
        cout << "Ant id: " << id << "; Step: " << step << endl;
#if 0
      if (ants[id].pc == 30) cout << "HELLS YEAH!" << endl;
      if (ants[id].pc == 29) cout << "HELLS YEAH!" << endl;
#endif
			if(doDebug && SIMDBG)
  			cout << "id: " << id << " pc: " << ants[id].pc << endl;

			col=ants[id].color;
			assert(ants[id].pc<algosize[col]);
			Command & cmd=algo[col][ants[id].pc];
			Point & cur=ants[id].pos;
			char & dir=ants[id].dir;
			switch(cmd.opcode)
			{
				case SENSE_HERE_MASK:
					next=cur;
					goto common_sense;
				case SENSE_AHEAD_MASK:
					getNeighbor(next,cur,dir);
					goto common_sense;  // ;-)
				case SENSE_LEFTAHEAD_MASK:
					getNeighbor(next,cur,turn(dir,LEFTDIR));
					goto common_sense;
				case SENSE_RIGHTAHEAD_MASK:
					getNeighbor(next,cur,turn(dir,RIGHTDIR));
common_sense:
					switch(cmd.arg)
					{
						case FRIEND_MASK:
							match=map.object[next.x][next.y]==col;
							break;
						case FOE_MASK:
							match=map.object[next.x][next.y]==otherColor(col);
							break;
						case FRIENDWITHFOOD_MASK:
							match = (map.object[next.x][next.y]==col) &&
							        (map.marker[col][next.x][next.y]&foodCarryCode);
							break;
						case FOEWITHFOOD_MASK:
							match = (map.object[next.x][next.y]==otherColor(col)) &&
							        (map.marker[otherColor(col)][next.x][next.y]&foodCarryCode);
							break;
						case FOOD_MASK:
							match=map.foodcount[next.x][next.y]>0;
							break;
						case ROCK_MASK:
							match=map.object[next.x][next.y]==WALL;
							break;
						case FOEMARKER_MASK:
							match = isMarked(map.marker[otherColor(col)][next.x][next.y]);
							break;
						case HOME_MASK:
							match = (map.marker[col][next.x][next.y]&homeCode);
							break;
						case FOEHOME_MASK:
							match = (map.marker[otherColor(col)][next.x][next.y]&homeCode);
							break;
						default: //MARKER_MASK+x
							match = (map.marker[col][next.x][next.y]&markerCode(cmd.arg-MARKER_MASK));
							break;
					}
					if(match) ants[id].pc=cmd.st1; else ants[id].pc=cmd.st2;
					break;
				case MARK_MASK:
					map.marker[col][cur.x][cur.y]|=markerCode(cmd.arg);
					ants[id].pc=cmd.st1;
					break;
				case UNMARK_MASK:
					if(map.marker[col][cur.x][cur.y] & markerCode(cmd.arg))
						map.marker[col][cur.x][cur.y]^=markerCode(cmd.arg);
					ants[id].pc=cmd.st1;
					break;
				case PICKUP_MASK:
					if(map.foodcount[cur.x][cur.y]>0 && !ants[id].has_food)
					{
						map.foodcount[cur.x][cur.y]--;
						ants[id].has_food=1;
						map.marker[col][cur.x][cur.y]^=foodCarryCode;
						ants[id].pc=cmd.st1;
					}
					else
						ants[id].pc=cmd.st2;
					break;
				case DROP_MASK:
					if(ants[id].has_food)
					{
						map.foodcount[cur.x][cur.y]++;
						ants[id].has_food=0;
						map.marker[col][cur.x][cur.y]^=foodCarryCode;
					}
					ants[id].pc=cmd.st1;
					break;
				case TURNRIGHT_MASK:
					dir=turn(dir,RIGHTDIR);
					ants[id].pc=cmd.st1;
					break;
				case TURNLEFT_MASK:
					dir=turn(dir,LEFTDIR);
					ants[id].pc=cmd.st1;
					break;
				case MOVE_MASK:
					getNeighbor(next,cur,dir);
					if(map.object[next.x][next.y]!=EMPTY)
						ants[id].pc=cmd.st2;
					else
					{
						map.object[next.x][next.y]=map.object[cur.x][cur.y];
						map.object[cur.x][cur.y]=EMPTY;
						if(ants[id].has_food)
						{
							map.marker[col][cur.x][cur.y]^=foodCarryCode;
							map.marker[col][next.x][next.y]^=foodCarryCode;
						}
						cur=next;
						ants[id].pc=cmd.st1;
						ants[id].resting=14;
						if(surrounded(cur,otherColor(col)))
							killAnt(ants[id]);
						else
						{
							for(char d=0;d<6;d++)
							{
								getNeighbor(next,cur,d);
								if(map.object[next.x][next.y]==otherColor(col))
									if(surrounded(next,col))
										killAnt(findAnt(next));
							}
						}
					}
					break;
				case FLIP_MASK:
					if(rand_get(cmd.arg)==0)
						ants[id].pc=cmd.st1;
					else
						ants[id].pc=cmd.st2;
					break;
				default:
					panic(); //unknown command
			}
		}

	}
}

void showResults()
{
  char col;
  int x,y;
	for(col=0;col<=1;col++)
	{
		int totfood=0;
		for(y=0;y<map.sizey;y++)
			for(x=0;x<map.sizex;x++)
				if(map.marker[col][x][y]&homeCode)
					totfood+=map.foodcount[x][y];
		printf("Color %d ants got %d food.\n",col,totfood);
	}

//	printMap(map);
//  printf("\n\nFOOD TRAILS!\n\n");
//  printTrails(map, RED, 0x07 << 3);
//  printf("\n\nHOME TRAILS!\n\n");
//  printTrails(map, RED, 0x07);
//  printf("\n\n0000 TRAILS!\n\n");
//  printTrails(map, RED, 0x01);
//  printf("\n\n1111 TRAILS!\n\n");
//  printTrails(map, RED, 0x02);
//  printf("\n\n2222 TRAILS!\n\n");
//  printTrails(map, RED, 0x04);
  //dumpState(map);
}