import java.applet.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import java.lang.*;

/** Conway's Game of Life
 * GameofLife.java
 *
 * @author J Scott Cameron
 */
public class GameofLife extends Applet
implements ActionListener, MouseListener, Runnable{
    
    
    /* awt components */
    Button randomInit = new Button("Random");
    Button clear = new Button("Clear");
    Button pause = new Button("Pause");
    Button step = new Button("Step");
    Checkbox cursor = new Checkbox("Cursor draws",true);
    
    /* lattice that holds state of the CA*/
    boolean board[][];
    
    Dimension size;
    Image buffer; /** buffer image for animated graphics **/
    Graphics bufferGraphics; /** Graphics object for animated graphics **/
    Thread animator; /** Thread that controls animation of applet **/
    Random random;
    boolean restart, paused, oneStep; /** booleans that hold information on
                                       *animation control **/
    int cellSize; /** size, in pixels, of cells on the board **/
    int boardWidth,boardHeight; /** dimensions of the board **/
    
    /**
     * init() sets up the applet, sets all the bounds for companents
     * and default values for those components that require values
     **/
    public void init() {
        random = new Random();
        setLayout(null);
        
        restart = false;
        paused = false;
        oneStep = false;
        randomInit.setBounds(5,405,60,20);
        clear.setBounds(70,405,60,20);
        pause.setBounds(135,405,60,20);
        step.setBounds(200,405,60,20);
        cursor.setBounds(265,405,100,20);
        cellSize = 4;
        
        randomInit.addActionListener(this);
        pause.addActionListener(this);
        step.addActionListener(this);
        clear.addActionListener(this);
        
        add(randomInit);
        add(pause);
        add(step);
        add(cursor);
        add(clear);
        
        size = new Dimension(600,400);
        boardWidth=size.width/cellSize;
        boardHeight=size.height/cellSize;
        
        addMouseListener(this);
        buffer = createImage(size.width, size.height);
        bufferGraphics = buffer.getGraphics();
        board= new boolean[boardWidth][boardHeight];
        
        animator = new Thread(this);
        
        for(int i=0;i<(boardWidth);i++)
        {
            for(int j=0;j<(boardHeight);j++)
            {
                
                if(Math.random() < .5)
                {
                    board[i][j] = false;
                }
                else
                {
                    board[i][j] = true;
                }
            }
        }
        animator.start();
    }
    
    /**
     *returns number of neighbors which are alive for latice
     *point (i,j)
     **/
    int neighborsAlive(int i, int j)
    {
        int count=0;
        
        count += isAlive(i-1,j-1);
        count += isAlive(i-1,j);
        count += isAlive(i-1,j+1);
        count += isAlive(i+1,j-1);
        count += isAlive(i+1,j);
        count += isAlive(i+1,j+1);
        count += isAlive(i,j-1);
        count += isAlive(i,j+1);
        
        return count;
    }
    
    /**
     *returns whether or not lattice point (i,j) is alive
     **/
    int isAlive(int i, int j)
    {
        if(board[(i+boardWidth)%boardWidth][(j+boardHeight)%boardHeight])
            return 1;
        return 0;
    }
    
    /**
     * updates the applet's board
     * using the rules of Conway's Game of Life
     **/
    synchronized void updateBoard()
    {
        boolean temp[][] = new boolean[(boardWidth)][(boardHeight)];
        int j,k,i;
        
        for( i=0; i<(boardWidth); i++)
        {
            for( j=0; j<(boardHeight); j++)
            {
                k = neighborsAlive(i,j);
                if(board[i][j])
                {
                    if(k < 2 || k > 3)temp[i][j]=false;
                    else temp[i][j]=true;
                }
                else
                {
                    if(k==3)temp[i][j]=true;
                    else temp[i][j]=false;
                }
            }
        }
        
        for(i=0;i<(boardWidth);i++)
        {
            for(j=0;j<(boardHeight);j++)
            {
                board[i][j]=temp[i][j];
            }
        }
    }
    
    /** ActionPerformed() catches the actionEvents (pressed buttons)
     * and sends it on to whatever function needs to be called
     * @param evt description of event
     */
    public void actionPerformed(ActionEvent evt)
    { Button theItem = (Button) evt.getSource();
    if (theItem == randomInit) randomPressed();
    else if (theItem == pause) pausePressed();
    else if (theItem == step) stepPressed();
    else if (theItem == clear) clearPressed();
    }
    
    /**
     * Generates a board with a random configuration
     **/
    public void randomPressed()
    {
        paused = true;
        for(int i=0;i<(size.width/cellSize);i++)
        {
            for(int j=0;j<(size.height/cellSize);j++)
            {
                if(Math.random() < .5)
                {
                    board[i][j] = false;
                }
                else
                {
                    board[i][j] = true;
                }
            }
        }
        repaint(0,0,size.width,size.height);
    }
    
    /**
     * toggles paused boolean
     **/
    public void pausePressed()
    {
        paused = !paused;
    }
    
    /**
     * advances board one step and pauses again
     **/
    public void stepPressed()
    {
        if(paused) paused = false;
        
        oneStep = true;
    }
    
    /**
     * clears board
     **/
    public void clearPressed()
    {
        paused = true;
        for(int i=0 ; i<boardWidth ; i++)
        {
            for(int j=0; j<boardHeight; j++)
            {
                board[i][j] = false;
            }
        }
        repaint(0,0,size.width,size.height);
    }
    
    /** overload of update(Graphics)
     * calls paint()
     * @param g graphics object to be updated
     */
    public synchronized void update(Graphics g)
    {
        paint(g);
    }
    
    /** updates all the graphics components.
     * uses a buffer swapping system for smooth
     * animation
     * @param g graphics object to be painted
     */
    public void paint(Graphics g) {
        bufferGraphics.setColor(this.getBackground());
        bufferGraphics.fillRect(0,0, size.width, size.height);
        bufferGraphics.setColor(Color.blue);
        
        
        
        for(int i=0;i<boardWidth;i++)
        {
            for(int j=0;j<boardHeight;j++)
            {
                if(board[i][j])
                {
                    /**
                     * if the cell is alive then fill the sqaure
                     **/
                    if(cellSize <=2)
                    {
                         /**
                          * if the cell size is smaller than 2
                          * we won't have whitespace between cells
                          **/
                        bufferGraphics.fillRect(i*cellSize,
                                                j*cellSize,
                                                cellSize,
                                                cellSize);
                    }
                    else
                    {
                        bufferGraphics.fillRect(i*cellSize,
                                                j*cellSize,
                                                cellSize-1,
                                                cellSize-1);
                    }
                }
            }
        }
        
        
        g.drawImage(buffer,0,0,this);
    }
    
    
    /**
     * This controls the thread. Checks to see if the applet is paused
     * otherwise it updates the board and redraws
     **/
    public void run() {
        while(!restart)
        {
            
            repaint(0,0,size.width,size.height);
            
            updateBoard();
            try{
                Thread.sleep(20);
            }
            
            catch(InterruptedException e)
            {
                ;
            }
            if(oneStep)
            {
                paused = true;
                oneStep = false;
            }
            while(paused)
            {
                ;
            }
            
            run();
        }
        
        restart =false;
        
        
    }
    
/** kills animator
 */
    public void stop() {animator = null;}
    
    
    /** This maps the mouse click and turns the appropriate cell on
     * @param p1 point where mouse click was recorded
     */
    public synchronized void mouseClicked(final java.awt.event.MouseEvent p1)
    {
        if((p1.getX()<size.width) && (p1.getY()<size.height))
        {
            board[p1.getX()/cellSize][p1.getY()/cellSize] = cursor.getState();
            repaint();
        }
    }
    
    /* these methods need to be implemented for the MouseListener interface
     * but I really have no use for them, so they'return empty*/
    public void mouseReleased(final java.awt.event.MouseEvent p1) {}
    public void mouseEntered(final java.awt.event.MouseEvent p1) {}
    public void mousePressed(final java.awt.event.MouseEvent p1) {}
    public void mouseExited(final java.awt.event.MouseEvent p1) {}
}