import java.util.*;
import java.io.*;

public class CA {

    private int[][] A;
    private int[][] B; // is A after deaths
    private int[][] C; // is new births in A
    private int[][] neighbourhood;
    private int n;
    private double pointSize;
    private boolean trace;
    private Random gen;
    private double density; // between 0 and 1
    private double pBirth, pDeath;
    private int population;
    private int iteration;

    public CA(int n,double density,double pBirth,double pDeath){
	this.n = n;
	gen = new Random();
	pointSize = 0.1;
	this.density = density;
	this.pBirth = pBirth;
	this.pDeath = pDeath;
	population = 0;
	iteration = 0;
	A = new int [n][n];
	B = new int [n][n];
	C = new int [n][n];
	neighbourhood = new int[2][9]; // see getNeighbourhood() for explanation
	for (int i=0;i<n;i++)
	    for (int j=0;j<n;j++) 
		if (gen.nextDouble() <= density){
		    A[i][j] = 1;
		    population++;
		}
		else
		    A[i][j] = 0;
    }

    private void getNeighbourhood(int[][] X,int x,int y){
	int k = 0;
	for (int i = Math.max(0,x-1);i<=Math.min(n-1,x+1);i++)
	    for (int j = Math.max(0,y-1);j<=Math.min(n-1,y+1);j++)
		if (X[i][j] == 0){
		    k++;
		    neighbourhood[0][k] = i;
		    neighbourhood[1][k] = j;
		}
	neighbourhood[0][0] = k;	
    }
    //
    // given cell X[x][y] find all Moore neighbouring cells that are unoccupied
    // place the locations in the array neighbourhood, with neighborhood[0][0]
    // being the number of entries in neighbourhood (maximum 8)
    //

    private void getToroidalNeighbourhood(int[][] X,int x,int y){
	int k = 0;
	int xt,yt; // x and y coords on torus
	for (int i=x-1;i<=x+1;i++)
	    for (int j=y-1;j<=y+1;j++){
		xt = i;
		if (i<0) xt = i + n;
                if (i>n-1) xt = n - i;
		yt = j;
		if (j<0) yt = j + n;
                if (j>n-1) yt = n - j;
		if (X[xt][yt] == 0){
		    k++;
		    neighbourhood[0][k] = xt;
		    neighbourhood[1][k] = yt;
		}
	    }
	neighbourhood[0][0] = k;	
    }
	
		
    public void iterate(){
	for (int i=0;i<n;i++) for (int j=0;j<n;j++){B[i][j] = C[i][j] = 0;}
	// death
	for (int i=0;i<n;i++)
	    for (int j=0;j<n;j++)
		if (A[i][j] == 1 && gen.nextDouble() <= pDeath){
		    B[i][j] = 1;
		    population--;
		    if (trace) System.out.println("-[" + i +"]["+ j +"]");
		}
	// birth
	for (int i=0;i<n;i++)
	    for (int j=0;j<n;j++)
		if (A[i][j] == 1 && gen.nextDouble() <= pBirth){
		    getToroidalNeighbourhood(A,i,j);
		    if (neighbourhood[0][0] > 0){
			int k = gen.nextInt(neighbourhood[0][0]) + 1;
			int x = neighbourhood[0][k];
			int y = neighbourhood[1][k];
			if (C[x][y] == 0){
			    C[x][y] = 1;
			    population++;
			    if (trace) System.out.println("+[" + x +"]["+ y +"]");
			}
		    }
		}
	// Copy over A = A - B + C
	for (int i=0;i<n;i++)
	    for (int j=0;j<n;j++)
		A[i][j] = A[i][j] - B[i][j] + C[i][j];
	iteration++;
    }		

    public void plot() {
	StdDraw.clear(StdDraw.LIGHT_GRAY);
	StdDraw.setXscale(-2,n);
        StdDraw.setYscale(-2,n);
        StdDraw.show(0);	
	for (int i=0;i<n;i++)
	    for (int j=0;j<n;j++)
		if (A[i][j] != 0) StdDraw.circle(i,j,pointSize);
	StdDraw.textLeft(-2,-2,stats());
        StdDraw.show(0);
    }

    public boolean trace(){trace = !trace; return trace;}
    public boolean getTrace(){return trace;}
    public void setPointSize(double x){pointSize = x;}
    public void setDensity(double p){density = p;}
    public void setBirth(double p){pBirth = p;}
    public void setDeath(double p){pDeath = p;}
    public int size(){return n;}
    public int getIteration(){return iteration;}
    public int getPopulation(){return population;}

    public void pause(long l){
	try{Thread.sleep(l);}
	catch (Exception e) {e.printStackTrace();}
    }

    public String stats(){
	String s = "n: " + n + " birth: " + pBirth + " death: " + pDeath + " pop: " + population;
	s = s + " iteration: " + iteration;
	return s;
    }
}