#include <stdio.h>
#include <stdlib.h>
#include "mpi.h"
#include <GL/glut.h>
#include <math.h>
#include <string.h>
#define N 1200
#define max 120
#define side 10
//initialization of variables
int runtime=0;
int exitp = 100;
int amount = 1;
int nump = 9;
int board = 120;
int flag = -1;
int arr[max][max];
int rec[max][max];
int x,y;
int temp[max][max];
int rank,size;
int k,tag=0;
MPI_Status status;
FILE* outfile;
//display function, prints to grid
void display()
{
	glClear(GL_COLOR_BUFFER_BIT);
	glColor3f(0.0,0.0,0.0);
	for(x=0;x<max;x++)
		for(y=0;y<max;y++)
		{
			if(arr[x][y])
				glRectd(1.0*x*side/N,1.0*y*side/N,1.0*(x+1)*side/N,1.0*(y+1)*side/N);
		}
	glutSwapBuffers();
}
//checks neighboring squares
int neighbors(int a,int b)
{
	int count=0;
	if(a>0 && arr[a-1][b]==1)
 		count++;
	if(a+1<max && arr[a+1][b]==1)
		count++;
	if(b>0 && arr[a][b-1]==1)
		count++;
	if(b+1<max && arr[a][b+1]==1)
		count++;
	if(b+1<max && a+1<max && arr[a+1][b+1]==1)
		count++;
	if(b>0 && a>0 && arr[a-1][b-1]==1)
		count++;
	if(b+1<max && a>0 && arr[a-1][b+1]==1)
		count++;
	if(a+1<max && b>0 && arr[a+1][b-1]==1)
		count++;
	return count;
}
//initializes array randomly
void createArray()
{
	int n,m;
	for(n=0;n<max;n++)
		for(m=0;m<max;m++)
		{
			if(1.0*rand()/RAND_MAX<0.25)
			{
				arr[n][m]=1;
			}
			else
			{
			arr[n][m]=0;
			}
		}
}
//takes a step in the program
void step(int n, int m, int xymax, int size)
{

	int xmax=n+xymax;
	int ymax=m+xymax;
	for(x=n;x<xmax;x++)
		for(y=m;y<ymax;y++)
		{
			int alive=neighbors(x,y);
			if (alive==3&&arr[x][y]==0)
				temp[x][y]=1;
			else if (alive>3&&arr[x][y]==1)
				temp[x][y]=0;
			else if (alive<2&&arr[x][y]==1)
				temp[x][y]=0;
			else
				temp[x][y]=arr[x][y];
		}
	for(x=n;x<xmax;x++)
		for(y=m;y<ymax;y++)
			arr[x][y]=temp[x][y];
}
//sets up relationship between processors and passes/receives information
void move()
{
	int xymin = 0;
	int xymax = max/sqrt(size);
	int xs=((int)rank)%((int)sqrt(size));
	int ys=((int)rank)/((int)sqrt(size));
	int xa=xs*xymax;
	int ya=ys*xymax;
	step(xa,ya,xymax,size);
	if (xs>0)
		MPI_Send(arr,max*max,MPI_INT,rank-1,tag,MPI_COMM_WORLD);
	if (xs<sqrt(size)-1)
		MPI_Send(arr,max*max,MPI_INT,rank+1,tag,MPI_COMM_WORLD);
	if (ys>0)
		MPI_Send(arr,max*max,MPI_INT,rank-sqrt(size),tag,MPI_COMM_WORLD);
	if (ys<sqrt(size)-1)
		MPI_Send(arr,max*max,MPI_INT,rank+sqrt(size),tag,MPI_COMM_WORLD);
	//after sending, all computers waiting for other processes
	if (xs>0)
	{
		MPI_Recv(rec,max*max,MPI_INT,rank-1,tag,MPI_COMM_WORLD,&status);
		for (x=amount;x>=1;x--)
		for (y=ya;y<ya+xymax;y++)
			arr[xa-amount][y]=rec[xa-amount][y];
	}
	if (xs<sqrt(size)-1)
	{
		MPI_Recv(rec,max*max,MPI_INT,rank+1,tag,MPI_COMM_WORLD,&status);
		for(x=amount;x>=1;x--)
		for(y=ya;y<ya+xymax;y++)
			arr[xa+xymax+amount-1][y]=rec[xa+xymax+amount-1][y];
	}
	if (ys>0)
	{
		MPI_Recv(rec,max*max,MPI_INT,rank-sqrt(size),tag,MPI_COMM_WORLD,&status);
		for (y=amount;y>=1;y--)
		for (x=xa;x<xa+xymax;x++)
			arr[x][ya-amount]=rec[x][ya-amount];
	}
	if (ys<sqrt(size)-1)
	{
		MPI_Recv(rec,max*max,MPI_INT,rank+sqrt(size),tag,MPI_COMM_WORLD,&status);
		for (y=amount;y>=1;y--)
		for (x=xa;x<xa+xymax;x++)
			arr[x][ya+xymax+amount-1]=rec[x][ya+xymax+amount-1];
	}
}
//called by the idle function to continue running automatically
void redisplay()
{
	//exitp is the number of steps before the program automatically quits
	if (exitp<=0)
	{
		runtime=glutGet(GLUT_ELAPSED_TIME);
		char ch[100];
		char tempch[10];

		strcpy(ch, "pr:");
		sprintf(tempch,"%d",nump);
		strcat(ch,tempch);

		strcat(ch,",pa:");
		sprintf(tempch,"%d",amount);
		strcat(ch,tempch);

		strcat(ch, ",bs:");
		sprintf(tempch,"%d",max);
		strcat(ch,tempch);

		strcat(ch,",rt:");
		sprintf(tempch,"%d",runtime);
		strcat(ch, tempch);
		strcat(ch,"\n");

		//prints out data to an outfile with information on variables
		fwrite(&ch,sizeof(char),strlen(ch),outfile);
		printf("time elapsed:%i\n",runtime);
		printf("amount:%i,nump:%i,board=%i",amount,nump,board);
		exit(0);
	}
	//gives main processor cue to continue and sends continue signal to other processors
	if (flag==-1)
	{
		int cont=1;
		for (x=1;x<size;x++)
			MPI_Send(&cont,1,MPI_INT,x,tag,MPI_COMM_WORLD);
		move();
		int z=0;
	//waits to receive information from other processors
	for (z=1;z<size;z++)
	{
		int xs=((int)z)%((int)sqrt(size))*max/sqrt(size);
		int ys=((int)z)/((int)sqrt(size))*max/sqrt(size);
		MPI_Recv(rec,max*max,MPI_INT,z,tag,MPI_COMM_WORLD,&status);
		for (x=xs;x<xs+max/sqrt(size);x++)
			for (y=ys;y<ys+max/sqrt(size);y++)
				arr[x][y]=rec[x][y];
	}
	exitp--;
	glutPostRedisplay();
	}
}
//if user left clicks, simulation restarts
void restart()
{
	createArray();
	for (x=0;x<size;x++)
	{
		int signal=0;
		MPI_Send(&signal,1,MPI_INT,x,tag,MPI_COMM_WORLD);
		MPI_Send(arr,max*max,MPI_INT,x,tag,MPI_COMM_WORLD);
	}
}
//mouse function
void mouse(int button, int state, int x, int y)
{
	if(state==GLUT_DOWN&&button==GLUT_LEFT_BUTTON)
	{
		restart();
		glutPostRedisplay();
	}
	if(state==GLUT_DOWN&&button==GLUT_RIGHT_BUTTON)
	{
		flag=-flag;
	}
}
//main function, initializes glut, mpi, file i/o
int main(int argc,char* argv[])
{
	createArray();
 	char s[N];
   	int k=0;

	FILE* infile;

   	infile=fopen("lawl.txt","r");
	outfile=fopen("data.txt","a");
	if(infile==NULL)
   	{
	      	fprintf(stderr,"No such file.\n");
	      	return 1;
   	}
   	while(!feof(infile))
   	{
    	  fread(s+k,sizeof(char),1,infile);
    	  k++;
   	}
   	s[k]='\0';

   	fclose(infile);

	int n=0;
	int m=0;
	int value=0;
	char message[3];
	for (n=0;n<strlen(s);n++)
	{
		if (s[n]!=' ')
			message[m]=s[n];
		else
		{
			if(value==0)
				amount=atoi(message);
			if(value==1)
				nump=atoi(message); //unnecessary
			//if(value==2)
				//board=atoi(message); //not implemented
			value++;
			int q=0;
			for (q=0;q<3;q++)
			message[q]='\0';
			m=-1;
		}
		m++;
	}
	board=atoi(message);
	MPI_Init(&argc,&argv);
	MPI_Comm_size(MPI_COMM_WORLD,&size);
	MPI_Comm_rank(MPI_COMM_WORLD,&rank);
	//initializes glut and runs mpi in idlefunc
	if (rank==0)
	{
		glutInit(&argc,argv);
		glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);
		glutInitWindowSize(N,N);
		glutInitWindowPosition(100,100);
		glutCreateWindow("Game of Life");

		glClearColor(1.0,1.0,1.0,0.0);
		glMatrixMode(GL_PROJECTION);
		glLoadIdentity();
		glOrtho(0.0,1.0,0.0,1.0,-1.0,1.0);

		createArray();
		glutDisplayFunc(display);
		glutIdleFunc(redisplay);
		glutMouseFunc(mouse);
		glutMainLoop();
	}
	else
	{
		//other processor receiving signals to continue, calls move func
		while(flag==flag)
		{
			int signal;
			MPI_Recv(&signal,1,MPI_INT,0,tag,MPI_COMM_WORLD,&status);
			if (signal==1)
			{
				move();
				MPI_Send(arr,max*max,MPI_INT,0,tag,MPI_COMM_WORLD);
			}
			if (signal==0)
			{
				MPI_Recv(rec,max*max,MPI_INT,0,tag,MPI_COMM_WORLD,&status);
				for (x=0;x<max;x++)
					for(y=0;y<max;y++)
						arr[x][y]=rec[x][y];
			}
		}
	}
	MPI_Finalize();
	return 0;
}