import java.util.*;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class Sudoku extends JFrame
				implements ActionListener
{
	static Numbers One            = new Numbers(1);
	static Numbers Two            = new Numbers(2);
	static Numbers Three          = new Numbers(3);
	static Numbers Four           = new Numbers(4);
	static Numbers Five           = new Numbers(5);
	static Numbers Six            = new Numbers(6);
	static Numbers Seven          = new Numbers(7);
	static Numbers Eight          = new Numbers(8);
	static Numbers Nine           = new Numbers(9);
	static Strings Possibilities 	= new Strings(); //Must be below Numbers declarations
	static Solution Final        	= new Solution();
	static Solution Initial		= new Solution();
	JButton btnOption = new JButton("Generate");
	JButton[][]btn = new JButton[9][9];
	
	public Sudoku()	//Method to set up Sudoku JFrame
	{ 
		super("Sudoku");
		setSize(250, 290);
		setResizable(false);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		Container pane = getContentPane();
		setVisible(true);
		FlowLayout flow = new FlowLayout();
		pane.setLayout(flow);
		flow.setHgap(0); flow.setVgap(0);
		for(int r=0;r<9; r++) //Next 2 for loops are used to create and add 81 buttons. 1 button is 1 cell in the sudoku grid
		{
			for(int c=0;c<9; c++)
			{
				btn[r][c] = new JButton();
				btn[r][c].setMargin(new Insets(0,0,0,0));
				btn[r][c].setPreferredSize(new Dimension(25,25));
				btn[r][c].setText("0");
				btn[r][c].setFocusPainted(false);
				btn[r][c].addActionListener(this);
				btn[r][c].setActionCommand(Integer.toString(r)+Integer.toString(c));
				pane.add(btn[r][c]);
			}
		}
		btnOption.addActionListener(this);
		btnOption.setFocusPainted(false);
		pane.add(btnOption);
		setContentPane(pane);
	} 
	
	public static void main(String[] args) 
	{
		Sudoku mainFrame = new Sudoku();	//Show Sudoku  JFrame
	}
	
	public void actionPerformed(ActionEvent e) 
	{
		JButton buttonPressed = (JButton)e.getSource(); //Identify button pressed
		int btnRow=-1, btnCol=-1;
		for(int row=0; row<9; row++)
		{
			for(int col=0; col<9; col++)
			{
				if(buttonPressed.equals(btn[row][col]))
				{
					btnRow = row; btnCol=col;	//determines the coordinates of the cell button pressed.
				}
			}
		}
		if(btnRow!=-1 && btnCol!=-1) //when a cell button is pressed its value is incremented by one in the body of this if
		{
			String buttonText = btn[btnRow][btnCol].getText();
			int buttonInt = Integer.parseInt(buttonText);
			if(buttonInt <9) buttonInt += 1;
			else buttonInt = 0;
			buttonText = Integer.toString(buttonInt);
			btn[btnRow][btnCol].setText(buttonText);
		}
		else if ("Generate".equals(e.getActionCommand())) //else if the option button is pressed in generation mode a solution is generated
		{
			for(int row=0; row<9; row++)
			{
				for(int col=0; col<9; col++)
				{
					Initial.Table[row][col]=Integer.parseInt(btn[row][col].getText()); //The initial table is set using the values of the cell buttons
				}
			}
			System.out.print("Initial Table Stored\n");
			Final.setTable();	//The final solution is set to the same as the initial table
			System.out.print("Final set to same as initial\n"); ///Error occurs after here
			Final.Generate();	//Then the generation method is called
			System.out.print("Solution Generated\n");
			for(int row=0; row<9; row++)
			{
				for(int col=0; col<9; col++)
				{
					btn[row][col].setText(Integer.toString(Final.Table[row][col]));	//The cell buttons text is changed to the new solution once it has been generated
				}
			}
			System.out.print("Solution Output\n");
			btnOption.setText("Reset");
			btnOption.setActionCommand("Reset");
			btnOption.setToolTipText("Click this button to reset");
			System.out.print("Button Changed to Reset\n");
		}
		else if("Reset".equals(e.getActionCommand())) //else if the option button is pressed in reset mode the whole process is ready to start again.
		{
			for(int row=0; row<9; row++)
			{
				for(int col=0; col<9; col++)
				{
					btn[row][col].setText("0");
				}
			}
			System.out.print("Cell Buttons Reset\n");
			btnOption.setText("Generate");
			btnOption.setActionCommand("Generate");
			btnOption.setToolTipText("Click this button to generate a solution");
			Initial.ZeroTable();
			System.out.print("Initial Table Zeroed\n");
			restart();
			System.out.print("Restart Called\n\n");
		}
	}

	static void Update()
	{
		One.Update(1);
		Two.Update(2);
		Three.Update(3);
		Four.Update(4);
		Five.Update(5);
		Six.Update(6);
		Seven.Update(7);
		Eight.Update(8);
		Nine.Update(9);
		Possibilities.Update();
	}
    
	static void restart()
	{
		Sudoku.One.Initialise(1);
		Sudoku.Two.Initialise(2);
		Sudoku.Three.Initialise(3);
		Sudoku.Four.Initialise(4);
		Sudoku.Five.Initialise(5);
		Sudoku.Six.Initialise(6);
		Sudoku.Seven.Initialise(7);
		Sudoku.Eight.Initialise(8);
		Sudoku.Nine.Initialise(9);
		Sudoku.Final.setTable();
	}
}

class Numbers 
{
	int[][]Table = new int[9][9];
    
	public Numbers(int value)   
	{
		Initialise(value); 
	}
    
	void Initialise(int value)
	{
		for(int row=0; row<9; row++)       //Nested for loops used
		{                                   //to address each cell
			for(int col=0; col<9; col++)   //of the objects table
			{
				Table[row][col]=value;
			}
		}
	}

	void Update(int value)   //Update the strings table to show which values are still available for the puzzle
	{
		for(int row=0; row<9; row++)
		{
			for(int col=0; col<9; col++)
			{
				boolean rowcon;
				boolean colcon;
				if(Sudoku.Final.Table[row][col]>0)Table[row][col] = 0;
				rowcon  = Sudoku.Final.getRow(row, value);       //Check the current row for the table value
				if(rowcon==true) Table[row][col] = 0;
				colcon  = Sudoku.Final.getCol(col, value);       //Check the current col for the table value
				if(colcon==true) Table[row][col] = 0;
				boolean square  = Sudoku.Final.getSquare(row, col, value); //Check the square the cell is in for the table value
				if(square==true) Table[row][col] = 0;
			}
		}
	}
    
	void Zero(int row, int col) //Redundant, but can be used to speed up processing
	{
		Table[row][col] = 0;
	}
}

class Strings
{
	static String[][]Table = new String[9][9];
	
	String One, Two, Three, Four, Five, Six, Seven, Eight, Nine;
	public Strings() 
	{
		Update();
	}
    
	void Update() 
	{	
		for(int row=0; row<9; row++)
		{
			for(int col=0; col<9; col++)
			{
				if(Sudoku.One.Table[row][col]==1)One="1"; else One="";
				if(Sudoku.Two.Table[row][col]==2)Two="2"; else Two="";
				if(Sudoku.Three.Table[row][col]==3)Three="3"; else Three="";
				if(Sudoku.Four.Table[row][col]==4)Four="4"; else Four="";
				if(Sudoku.Five.Table[row][col]==5)Five="5"; else Five="";
				if(Sudoku.Six.Table[row][col]==6)Six="6"; else Six="";
				if(Sudoku.Seven.Table[row][col]==7)Seven="7"; else Seven="";
				if(Sudoku.Eight.Table[row][col]==8)Eight="8"; else Eight="";
				if(Sudoku.Nine.Table[row][col]==9)Nine="9"; else Nine="";
				Table[row][col]  = One+Two+Three+Four+Five+Six+Seven+Eight+Nine;
			}
		}
	}
}

class Solution 
{
	static Random generator = new Random();
	int[][]Table = new int[9][9];
    
	public Solution() 
	{
		ZeroTable();
	}
    
	void setTable()
	{
		Table=Sudoku.Initial.Table;
		Sudoku.Update();
	}
    
	void ZeroTable()
	{
		for(int row=0;row<9;row++)
		{
			for(int col=0; col<9; col++)
			{
				Table[row][col]=0;
			}
		}
	}
    
	void Generate()
	{
		while(containsZeros()==true)///infinate loop here, unsure why?
		{
			genCell();
			System.out.print("\tgencell called\n");
			Sudoku.Update();
			System.out.print("\tUpdate all tables and possibilities\n"); 
		}
	}
    
	private void genCell()
	{
		int row=0, col=0, cellLength=9;
		
		for(int r=0; r<9; r++)  //Following for loops used to choose the cell with the minimum possibilities
		{
			for(int c=0; c<9; c++)
			{
				if(Sudoku.Possibilities.Table[r][c].length()<cellLength)
				{
					if(Sudoku.Possibilities.Table[r][c].length()==0){}
					else
					{
						cellLength = Sudoku.Possibilities.Table[r][c].length();
						row = r;
						col = c;
					}
				}
			}
		}
	   
		int value=0, index=0, length=Sudoku.Possibilities.Table[row][col].length();
		if(length>0)
		{
			index=generator.nextInt(length);
			value = Sudoku.Possibilities.Table[row][col].charAt(index);//This returns the ascii code of the char at point index
		}
		else
		{
			Sudoku.restart();
		}	
        
		//Convert the ascii code to its char equivelent but as an integer using these else if statements 
		if(value=='1')value=1;
		else if(value=='2')value=2;
		else if(value=='3')value=3;     
		else if(value=='4')value=4;
		else if(value=='5')value=5;
		else if(value=='6')value=6;    
		else if(value=='7')value=7;
		else if(value=='8')value=8;
		else if(value=='9')value=9;
        
		Table[row][col]=value;
	}

	private boolean containsZeros()
	{
		boolean contains=false;
		int attempts=0;
		for(int row=0; row<9; row++)
		{
			for(int col=0; col<9; col++)
			{
				if(Table[row][col]==0)
				{
					contains=true;
					System.out.print("\t\tIt contains zeros... col=" +col+ "... row="+row+"\n");
				}
				attempts+=1;
				
			}
			
		}
		return(contains);
	}
    
	boolean getRow(int row, int value)
	{
		boolean contains=false, end=false;
		int col=0;
		while(contains==false && end==false)
		{
			if(Sudoku.Final.Table[row][col]==value) contains = true;
			else contains = false;
			col++;
			if(col>8) end=true;
		}
		return(contains);
	}
    
	boolean getCol(int col, int value)
	{
		boolean contains=false, end=false;
		int row=0;
		while(contains==false && end==false)
		{
			if(Sudoku.Final.Table[row][col]==value) contains = true;
			row++;
			if(row>8) end=true;
		}
		return(contains);
	}
    
	boolean getSquare(int row, int col, int value)
	{
		boolean contains=false;
		if(row==0 || row==1 || row==2)
		{
			if(col==0 || col==1 || col==2)
			{
				contains=checkSquare(0, 0, value);
			}
			if(col==3 || col==4 || col==5)
			{
				contains=checkSquare(0, 3, value);
			}
			if(col==6 || col==7 || col==8)
			{
				contains=checkSquare(0, 6, value);
			}
		}
		if(row==3 || row==4 || row==5)
		{
			if(col==0 || col==1 || col==2)
			{
				contains=checkSquare(3, 0, value);
			}
			if(col==3 || col==4 || col==5)
			{
				contains=checkSquare(3, 3, value);
			}
			if(col==6 || col==7 || col==8)
			{
				contains=checkSquare(3, 6, value);
			}
		}
		if(row==6 || row==7 || row==8)
		{
			if(col==0 || col==1 || col==2)
			{
				contains=checkSquare(6, 0, value);
			}
			if(col==3 || col==4 || col==5)
			{
				contains=checkSquare(6, 3, value);
			}
			if(col==6 || col==7 || col==8)
			{
				contains=checkSquare(6, 6, value);
			}
		}
		return(contains);
	}

	public void Print()
	{
		System.out.print(" ------- ------- -------	\n");
		for(int row=0; row<9; row++)
		{
			System.out.print("| ");
			for(int col=0; col<9; col++)
			{
				System.out.print(+ Table[row][col] + " ");
				if(col==2||col==5||col==8)System.out.print("| ");
			}
			System.out.print("\n");
			if(row==2||row==5||row==8)System.out.print(" ------- ------- -------	\n");
		}
		System.out.print("\n");
	}
    
	boolean checkSquare(int row, int col, int value)
	{
		boolean contains=false;
		int r0w=row, c0l=col;
		for(int n=0; n<9; n++)
		{
			if(Sudoku.Final.Table[r0w][c0l]==value)
			{
				contains = true;
				break;
			}
			if(++c0l > col+2)
			{
				c0l=col;
				r0w++;
			}
		}
		return(contains);
	}
}

if(Table[row][col]==0)
{
	contains=true;
	System.out.print("\t\tIt contains zeros... col=" +col+ "... row="+row+"\n");
}