#include "adevs.h"
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <GL/glut.h>
using namespace std;
using namespace adevs;

/* A Parallel DEVS implementation of the game of life. */

/// Cellspace dimensions
#define WIDTH 800
#define HEIGHT 600
/// Possible cell phases.
typedef enum { Dead, Alive } Phase;
/// IO type for a cell
struct io_type
{
	int x, y;
	Phase phase;
};

/// A cell in the Game of Life.  
class Cell:
	public Atomic<io_type>
{
	public:
		/**
		 * Create a cell and set the initial state.
		 * The width and height fields are used to determine if a
		 * cell is an edge cell.  The last phase pointer is used to
		 * visualize the cell space.
		 */
		Cell(int x, int y, Phase phase, int nalive, Phase* vis_phase):
			Atomic<io_type>(),x(x),y(y),phase(phase),
			nalive(nalive),vis_phase(vis_phase){}
		// State transition functions
		void delta_int();
		void delta_ext(Time e, vector<io_type>& x);
		void delta_conf(vector<io_type>& x);
		// Time advance function
		Time ta();
		// Output function
		void output_func(vector<io_type>& y);

	private:	
		/// Location of the cell in the 2D space
		const int x, y;
		/// Current phase of this cell
		Phase phase;
		/// The number of living neighbors
		int nalive;
		/// Output variable for visualization
		Phase* vis_phase;
		/// Returns true if the cell will be born
		bool check_born_rule() const
		{
			return (phase == Dead && nalive == 3);
		}
		/// Return true if the cell will die
		bool check_death_rule() const
		{
			return (phase == Alive && (nalive < 2 || nalive > 3));
		}
};

Time Cell::ta()
{
	// If a phase change should occur
	if (check_death_rule() || check_born_rule())
		return Time(1,0);
	// Otherwise, do nothing
	return adevs_inf<Time>();
}

void Cell::delta_int() 
{
	assert(check_death_rule() || check_born_rule());
	phase = (check_death_rule()) ? Dead : Alive;
}

void Cell::delta_ext(Time, vector<io_type>& x) 
{
	// Update the count if living neighbors
	for (unsigned i = 0; i < x.size(); i++)
		nalive += (x[i].phase == Dead) ? -1 : 1;
}

void Cell::delta_conf(vector<io_type>& x) 
{
	delta_int();
	delta_ext(Time(0,0),x);
}

void Cell::output_func(vector<io_type>& y) 
{
	io_type msg;
	/// Report our new phase
	assert(check_born_rule() || check_death_rule());
	msg.phase = (phase == Alive) ? Dead : Alive;
	msg.x = this->x; msg.y = this->y;
	y.push_back(msg);
	/// Set the visualization value
	assert(vis_phase != NULL);
	*vis_phase = msg.phase;
}

// Phase space to visualize. Also used as our initial state.
Phase phase[WIDTH][HEIGHT];

/// A network model to hold our cell space
class CellSpace:
	public Network<io_type>
{
	public:
		/// Create the simulation models
		CellSpace():Network<io_type>()
		{
			for (int x = 0; x < WIDTH; x++)
			{
				for (int y = 0; y < HEIGHT; y++)
				{
					space[x][y] =
						new Cell(x,y, // Location
								phase[x][y], // Initial state
								count_neighbors(x,y), // Living neighbors
								&(phase[x][y])); // Visualization pointer
					// Set the parent so that messages can be routed
					assign_parent(space[x][y]);
				}
			}
		}
		/// Add the cells to the simulation context
		void add(SimEnv<io_type>* env)
		{
			for (int x = 0; x < WIDTH; x++)
				for (int y = 0; y < HEIGHT; y++)
					space[x][y]->add(env);
		}
		/// Route messages to the proper neighbors
		void route(Model<io_type> *src, io_type data, vector<pair<Model<io_type>*,io_type> > &msgs)
		{
			// Send the message to all neighbors
			for (int dx = -1; dx <= 1; dx++)
			{
				int x = data.x+dx;
				if (x < 0) x = WIDTH-1;
				if (x >= WIDTH) x = 0;
				for (int dy = -1; dy <= 1; dy++)
				{
					if (dx == 0 && dy == 0) continue;
					int y = data.y+dy;
					if (y < 0) y = HEIGHT-1;
					if (y >= HEIGHT) y = 0;
					msgs.push_back(pair<Model<io_type>*,io_type>(space[x][y],data));
				}
			}
		}
		/// Destructor destroys the cells too
		~CellSpace()
		{
			for (int x = 0; x < WIDTH; x++)
				for (int y = 0; y < HEIGHT; y++)
					delete space[x][y];
		}
	private:
		int count_neighbors(int cx, int cy)
		{
			int nalive = 0;
			for (int dx = -1; dx <= 1; dx++)
			{
				int x = cx+dx;
				if (x < 0) x = WIDTH-1;
				if (x >= WIDTH) x = 0;
				for (int dy = -1; dy <= 1; dy++)
				{
					if (dx == 0 && dy == 0) continue;
					int y = cy+dy;
					if (y < 0) y = HEIGHT-1;
					if (y >= HEIGHT) y = 0;
					nalive += phase[x][y] == Alive;
				}
			}
			return nalive;
		}
		Cell* space[WIDTH][HEIGHT];
};

// Window and cell dimensions. 
#define CELL_SIZE 1
const GLint win_width = WIDTH*CELL_SIZE; 
const GLint win_height = HEIGHT*CELL_SIZE;

void drawSpace()
{
	static bool init = true;
	if (init)
	{
		init = false;
		glutUseLayer(GLUT_NORMAL);
		glClearColor(0.0,0.0,1.0,1.0);
		glColor3f(1.0,1.0,1.0);
		glMatrixMode(GL_PROJECTION);
		glLoadIdentity();
		glOrtho(0.0,(float)win_width,0.0,(float)win_height,1.0,-1.0);
	}
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	for (int x = 0; x < WIDTH; x++)
	{
		for (int y = 0; y < HEIGHT; y++)
		{
			if (phase[x][y] == Alive) 
			{
				GLint wx = CELL_SIZE*x;
				GLint wy = CELL_SIZE*y;
				glRecti(wx,wy,wx+CELL_SIZE,wy+CELL_SIZE);
			}
		}
	}
	glutSwapBuffers();
}

void simulateSpace()
{
	// Seed the random number generator
	srand(time(NULL));
	while (true)
	{
		// Randomize the initial state
		for (int x = 0; x < WIDTH; x++)
		{
			for (int y = 0; y < HEIGHT; y++)
			{
				if (rand()%8 == 0) phase[x][y] = Alive;
				else phase[x][y] = Dead;
			}
		}
		drawSpace();
		// Create the model and simulator
		CellSpace cell_space;
		Simulator<io_type> sim;
		cell_space.add(&sim);
		// While the space is evolving
		while (sim.next_event_time() < adevs_inf<Time>())
		{
			// Run the next simulation step
			sim.exec_next_event();
			// Draw the updated display
			drawSpace();
		}
	}
}

int main(int argc, char** argv)
{
	// Setup the display
	glutInit(&argc,argv);
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA);
	glutInitWindowSize(win_width,win_height);
	glutCreateWindow("glife");
	glutPositionWindow(0,0);
	glutDisplayFunc(drawSpace);
	glutIdleFunc(simulateSpace);
	glutMainLoop();
	// Done
	return 0;
}