package cc.glsn.v15.life;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GridBagConstraints;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.image.BufferedImage;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Random;
import javax.swing.JFrame;
import javax.swing.JPanel;

/**
 * 
 * http://en.wikipedia.org/wiki/Conway%27s_Game_of_Life
 */
public class Life
{

    /**
     * 
     */
    private static final long serialVersionUID = 1L;

    /**
     * @param args
     */
    public static void main(String[] args)
    {
        new Life(new LifeConfig());

    }
    
    LifeConfig LC;
    JFrame Frame;
    BoardPanel Pan;
    State StateA;
    Random R;
    
    HashSet<String> RecentStates;
    boolean ClickSpawn=false;
        
    
    public Life(LifeConfig lc)
    {
        LC=lc;
        R=new Random();
        RecentStates=new HashSet<String>(LC.MaxRecentStates,0.5f);
        
        StateA=new State();
        
        Frame=new JFrame("Life");
        Pan=new BoardPanel();
        
        Frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        
        Pan.addMouseListener(new Clicker());
        
        Frame.setContentPane(new JPanel(new java.awt.GridBagLayout()));

        {
            GridBagConstraints c=new GridBagConstraints();


            c.gridheight=1;
            c.gridwidth=1;
            c.fill=GridBagConstraints.NONE;
            c.insets=new java.awt.Insets(0,0,0,0);
            c.anchor=GridBagConstraints.WEST;


            Frame.getContentPane().add(Pan,c);
        }
        
        Frame.pack();
        Frame.setVisible(true);
        
        
        LinkedList<Point> Born=new LinkedList<Point>();
        LinkedList<Point> Dead=new LinkedList<Point>();
        
        while(true)
        {
            long A=System.currentTimeMillis();
            Born.clear(); Dead.clear();
            
            for(int i=0; i<LC.XCells; i++)
            for(int j=0; j<LC.YCells; j++)
            {
                if (StateA.Board[i][j]==1)
                {
                    if (!LC.Live[StateA.NCount[i][j]])
                    {
                        Dead.add(new Point(i,j));
                        
                    }
                    
                }
                else if (StateA.Board[i][j]==0)
                {
                    if (LC.Spawn[StateA.NCount[i][j]])
                    {
                        Born.add(new Point(i,j));
                    }
                    
                }
                
            }
            
            if (Dead.size() + Born.size()==0)
            {
                Born=spawn();
                
            }
            else if (ClickSpawn)
            {
                ClickSpawn=false;
                Born.addAll(spawn());
                
            }
            else
            {
                if (R.nextDouble() <= LC.StateCheckPercent)
                {
                    String S=StateA.toString();
                    if (RecentStates.contains(S))
                    {
                        Born.addAll(spawn());
                        RecentStates.clear();
                    }
                    else
                    {
                        RecentStates.add(S);
                        if (RecentStates.size()>=LC.MaxRecentStates) RecentStates.clear();
                    } 
                        
                    
                }
                
            }
            
            for(Point P : Born)
            {
                StateA.setCell(P.x,P.y,1);
                Pan.updateSpot(P.x,P.y,1);
            }
            for(Point P : Dead)
            {
                StateA.setCell(P.x,P.y,0);
                Pan.updateSpot(P.x,P.y,0);
            }
            
            
            Pan.repaint();
            
            long B=System.currentTimeMillis();
            
            //System.out.println(B-A);
            
            
            if (B-A < LC.MinFrameTime)
            {
                long S=LC.MinFrameTime-(B-A);
                try
                {                   Thread.sleep(S);
                }
                catch (InterruptedException e)
                {
                }
            }
            
        }
                
        
    }
    
    
    
    private LinkedList<Point> spawn()
    {
        //System.out.println("Spawning!");
        
        
        LinkedList<Point> L=new LinkedList<Point>();
        
        for(int i=0; i<LC.XCells; i++)
        for(int j=0; j<LC.YCells; j++)
        {
            double d=R.nextDouble();
            if (d <= LC.SpawnPercent)
            {
                L.add(new Point(i,j));
            }
        }
        

        return L;
    }



    class BoardPanel  extends JPanel
    {
        BufferedImage Img;
        
        BoardPanel()
        {
            Img=new BufferedImage(LC.XCells*LC.DispSize,LC.YCells*LC.DispSize,BufferedImage.TYPE_4BYTE_ABGR);
            Graphics g=Img.getGraphics();
            g.setColor(Color.BLACK);
            g.fillRect(0,0,LC.XCells*LC.DispSize,LC.YCells*LC.DispSize);
            
            g.setColor(Color.RED);
            for(int i=0; i<LC.XCells; i++)
            for(int j=0; j<LC.YCells; j++)
            {
                if (StateA.Board[i][j]==1)
                {
                    g.fillRect(i*LC.DispSize,j*LC.DispSize,LC.DispSize,LC.DispSize);
                }
            }
            
            repaint();
        }
        
        public void updateSpot(int x, int y, int State)
        {
            Rectangle R=new Rectangle(x*LC.DispSize,y*LC.DispSize,LC.DispSize,LC.DispSize);
            
            Graphics g=Img.getGraphics();
            if (State==1) g.setColor(Color.BLUE);
            else g.setColor(Color.BLACK);
            
            g.fillRect(R.x,R.y,R.width,R.height);
            
            //repaint(R);
            
        }
        
        protected synchronized void paintComponent(Graphics g)
        {
            Graphics2D g2=(Graphics2D)g;
            Rectangle R=g.getClip().getBounds();
            
            
            //g2.drawImage(Img,R.x,R.y,R.width,R.height,null);
            g2.drawImage(Img,R.x,R.y,R.x+R.width,R.y+R.height,R.x,R.y,R.x+R.width,R.y+R.height,null);
            
        }

        private static final long serialVersionUID = 4816256449493938254L;
        

        /** Used by some layout managers */
        public Dimension getMaximumSize()
        {
            return getPreferredSize();
        }

        /** Used by some layout managers */
        public Dimension getMinimumSize()
        {
            return getPreferredSize();
        }

        /** Used by some layout managers */
        public Dimension getPreferredSize()
        {
            return new Dimension(LC.XCells*LC.DispSize,LC.YCells*LC.DispSize);
        }
        
    }
   
    class State
    {
        int[][] Board;
        int[][] NCount;
        
        public State()
        {
        
            Board=new int[LC.XCells][LC.YCells];
            NCount=new int[LC.XCells][LC.YCells];
        
        }
        
        public void setCell(int i, int j, int State)
        {
            
            if (Board[i][j]!=State)
            {
                int NC=NCount[i][j];
                Board[i][j]=State;
                for(int a=i-1; a<=i+1; a++)
                {
                    int a2=a;
                    if (a2<0) a2+=LC.XCells;
                    else if (a2>=LC.XCells) a2-=LC.XCells;
                    
                    for(int b=j-1; b<=j+1; b++)
                    {
                        int b2=b;
                        if (b2<0) b2+=LC.YCells;
                        else if (b2>=LC.YCells) b2-=LC.YCells;
                        
                        if (State==0) NCount[a2][b2]--;
                        else NCount[a2][b2]++;
                        
                    }
                }
                NCount[i][j]=NC;
            }
        }
        
        public String toString()
        {
            StringBuilder SB=new StringBuilder((LC.XCells+1)*LC.YCells);
            
            for(int j=0; j<LC.YCells; j++)
            {
                
                for(int i=0; i<LC.XCells; i++)
                {
                    SB.append(Board[i][j]);
                    
                }
                char N=10;
                SB.append(N);
                
            }
            
            return SB.toString();
            
            
        }
    }
    
    class Clicker implements MouseListener
    {

        public void mouseClicked(MouseEvent arg0)
        {
            ClickSpawn=true;
            
        }

        public void mousePressed(MouseEvent arg0)
        {
            // TODO Auto-generated method stub
            
        }

        public void mouseReleased(MouseEvent arg0)
        {
            // TODO Auto-generated method stub
            
        }

        public void mouseEntered(MouseEvent arg0)
        {
            // TODO Auto-generated method stub
            
        }

        public void mouseExited(MouseEvent arg0)
        {
            // TODO Auto-generated method stub
            
        }
        
    }

}