//
// CA to be used by Gillespie
//
import java.util.*;
import java.io.*;
import java.awt.*;

public class GCA {

    private int[][] A;
    private int[] neighbourhood;
    private int n;                // n X n grid, as a torus
    private int m;                // m species
    private int population;       // sum of all species
    private double pointSize;
    private boolean trace;
    private RandomSet[] S;        // one for each species
    private RandomSet freeSpace;
    private Random gen;
    private int events;           // number of events
    private boolean draw;         // true <-> plot
    private static int empty = -1;
    private static Color background = Color.LIGHT_GRAY;
    private static Color[] color = {Color.BLUE,Color.RED,Color.YELLOW,Color.GREEN,Color.CYAN,Color.MAGENTA};

    public GCA(int n,int m,boolean draw){
	this.n        = n;
	this.m        = m;
	this.draw     = draw;
	pointSize     = 0.4;
	gen           = new Random();
	A             = new int [n][n];
	S             = new RandomSet[m];
	freeSpace     = new RandomSet(n*n);
	neighbourhood = new int [9]; // see getNeighbourhood() for explanation
	for (int i=0;i<m;i++) S[i] = new RandomSet(n*n);
	for (int i=0;i<n;i++)
	    for (int j=0;j<n;j++){
		A[i][j] = empty;
		freeSpace.add(i*n+j);
	    }
	population = events = 0;
	if (draw) plot();
    }

    public void add(int species) throws RandomSetException {
	int x = freeSpace.delete();
	int i = x/n;
	int j = x%n;
	A[i][j] = species;
	S[species].add(x);
	population++;
	if (draw) plot(i,j,color[species]);
    }
    //
    // add a new member of species to the population
    //

    public void death(int species) throws RandomSetException {
	int x = S[species].delete();
	int i = x/n;
	int j = x%n;
	A[i][j] = empty;
	population--;
	events++;
	if (draw) unPlot(i,j);
    }
    //
    // kill a member of species from the population
    //
	

    private void getNeighbourhood(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 (A[i][j] == empty){
		    k++;
		    neighbourhood[k] = i*n + j;
		}
	neighbourhood[0] = k;	
    }
    //
    // given cell A[x][y] find all Moore neighbouring cells that are unoccupied
    // place the locations in the array neighbourhood, with neighborhood[0]
    // being the number of entries in neighbourhood (maximum 8)
    //

    private void getToroidalNeighbourhood(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 (A[xt][yt] == empty){
		    k++;
		    neighbourhood[k] = xt*n + yt;
		}
	    }
	neighbourhood[0] = k;	
    }
	
		
    public boolean birth(int species) throws RandomSetException {
	events++;
	int x = S[species].select();
	int i = x/n;
	int j = x%n;
	getToroidalNeighbourhood(i,j);
	if (neighbourhood[0] > 0){
	    int k = gen.nextInt(neighbourhood[0]) + 1;
	    int y = neighbourhood[k];
	    A[y/n][y%n] = species;
	    S[species].add(y);
	    population++;
	    if (draw) plot(y/n,y%n,color[species]);
	    return true;
	}
	//System.out.println("blip");
	return false;
    }		

    public void plot() {
	StdDraw.clear(background);
	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] != empty){
		    StdDraw.setPenColor(color[A[i][j]]);
		    StdDraw.filledSquare(i,j,pointSize);
		}
	/*
       	for (int i=0;i<m;i++){
	    StdDraw.setPenColor(color[i]);
	    StdDraw.textLeft((i*n/10)-2,-2,Integer.toString(S[i].size()));
	}
	*/
	StdDraw.show(0);
    }

    public void plot(int x,int y,Color color){
	StdDraw.setPenColor(color);
	StdDraw.filledSquare(x,y,pointSize);
	StdDraw.show(0);
    }

    public void unPlot(int x,int y){
	StdDraw.setPenColor(background);
	StdDraw.filledSquare(x,y,pointSize+0.02);
	StdDraw.show(0);
    }

    public boolean trace(){trace = !trace; return trace;}
    public boolean getTrace(){return trace;}
    public void    setPointSize(double x){pointSize = x;}
    public int     size(){return n;}
    public int     getPopulation(){return population;}
    public String  stats(){return population +" "+ events;}

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

}