package sudoku;

import java.util.Random;

import javax.swing.JFrame;

public class sudoku1
{
    public static int[][] set()
    {

        int[][] board =
            {
                {0,0,0,0,0,0,0,0,0},
                {0,0,0,0,0,0,0,0,0},
                {0,0,0,0,0,0,0,0,0},
                {0,0,0,0,0,0,0,0,0},
                {0,0,0,0,0,0,0,0,0},
                {0,0,0,0,0,0,0,0,0},
                {0,0,0,0,0,0,0,0,0},
                {0,0,0,0,0,0,0,0,0},
                {0,0,0,0,0,0,0,0,0}
            };

        if(Solve(board))
        {
        shuffle(board);
        }
        return board;
    }

    public static void Print(int[][] board)
    {
        for(int i=0; i<9; i++)
        {
            for(int j=0; j<9; j++)
            {
                System.out.print(board[i][j]+" ");
            }
            System.out.println();
        }
    }

    public static boolean Solve(int board[][])
    {
        int [][] status= new int[board.length][board[0].length];
         for (int i=0; i<9; i++)
         {
             for(int j=0; j<9; j++)
             {
                 status[i][j]= board[i][j]>0?2:0;
             }
         }

          return Solve(board, status,0,0);

    }

    public static boolean Solve (int[][] board, int[][] status, int x, int y)
    {

        if (x==9)
        {
            int count= 0;
            for (int i=0; i<9; i++)
            {
                for(int j=0; j<9; j++)
                {
                    count+= status[i][j]>0?1:0;
                }
            }

            if(count==81)
            {
                return true;
            }
            else
            {
                return false;
            }

        }

        if(status[x][y]>=1)
        {
            int nextX= x;
            int nextY= y+1;
            if(nextY==9)
            {
                nextX= x+1;
                nextY=0;
            }

            return Solve(board, status, nextX, nextY);
        }
        else
        {
            boolean[] used= new boolean[9];
            for(int i=0;i<9;i++)
            {
                if(status[x][i]>=1)
                {
                    used[board[x][i]-1]=true;
                }
            }

            for(int i=0; i<9;i++)
            {
                if(status[i][y]>=1)
                {
                    used[board[i][y]-1]= true;
                }
            }

            for(int i=x-(x%3);i<x-(x%3)+3;i++)
            {
                for (int j=y-(y%3);j<y-(y%3)+3;j++)
                {
                    if(status[i][j]>=1)
                    {
                        used[board[i][j]-1]= true;
                    }
                }
            }// For cikla beigas

            for (int i=0; i<used.length;i++)
            {
                if(!used[i])
                {
                    status[x][y] = 1;
                    board[x][y]= i+1;

                    int nextX= x;
                    int nextY=y+1;

                    if(nextY==9)
                    {
                        nextX= x+1;
                        nextY= 0;
                    }

                    if(Solve(board, status, nextX, nextY))
                    {
                        return true;
                    }

                    for(int m=0; m<9; m++)
                    {
                        for (int n=0; n<9; n++)
                        {
                            if(m>x||(m==x&&n>=y))
                            {
                                if(status[m][n]==1)
                                {
                                    status[m][n]=0;
                                    board[m][n]=0;
                                }
                            }
                        }
                }


                }
            } // for cikla beigas

        }

        return false;
    }

    public static void shuffle(int[][] table)
    {
        Random rand= new Random();

        for(int i=0; i<100;i++) // cik reizes šo visu darīs.
        {

            for(int j=0;j<9;j++)
            {
                for(int k= j;k<9; k++ )
                {
                    int change_value=table[j][k];
                    table[j][k]=table[k][j];
                    table[k][j]=change_value;
                }
            }

            for(int j=0; j< 1000;j++) //cik reizes samainīs rindas.
            {
                int row= rand.nextInt(9);
                int which= which_one(row);



                for(int k=0; k<9;k++) //rindu maiņa.
                {
                    int change_value=table[row][k];
                    table[row][k]=table[which][k];
                    table[which][k]=change_value;
                }
                for(int k=0; k<9;k++) //kolonu maiņa maiņa.
                {
                    int change_value=table[k][row];
                    table[k][row]=table[k][which];
                    table[k][which]=change_value;
                }

                switch(rand.nextInt(3)) // Saimaina ||
                {
                case 0:
                        row=3+ rand.nextInt(2)*3;
                        for(int l=0;l<3;l++)
                            {
                                for (int k=0;k<9;k++)
                                {
                                    int change_value=table[l][k];
                                    table[l][k]=table[l+row][k];
                                    table[l+row][k]=change_value;
                                }
                            }
                        break;

                case 1:
                    row=(int) (3* Math.pow(-1, rand.nextInt(2)+1));
                    for(int l=3;l<6;l++)
                        {
                            for (int k=0;k<9;k++)
                            {
                                int change_value=table[l][k];
                                table[l][k]=table[l+row][k];
                                table[l+row][k]=change_value;
                            }
                        }
                    break;

                case 2:
                    row=-3- rand.nextInt(2)*3;
                    for(int l=6;l<9;l++)
                        {
                            for (int k=0;k<9;k++)
                            {
                                int change_value=table[l][k];
                                table[l][k]=table[l+row][k];
                                table[l+row][k]=change_value;
                            }
                        }
                    break;

                }

                switch(rand.nextInt(3)) // Saimaina =
                {
                case 0:
                        row=3+ rand.nextInt(2)*3;
                        for(int l=0;l<3;l++)
                            {
                                for (int k=0;k<9;k++)
                                {
                                    int change_value=table[k][l];
                                    table[k][l]=table[k][l+row];
                                    table[k][l+row]=change_value;
                                }
                            }
                        break;

                case 1:
                    row=(int) (3* Math.pow(-1, rand.nextInt(2)+1));
                    for(int l=3;l<6;l++)
                        {
                            for (int k=0;k<9;k++)
                            {
                                int change_value=table[k][l];
                                table[k][l]=table[k][l+row];
                                table[k][l+row]=change_value;
                            }
                        }
                    break;

                case 2:
                    row=-3- rand.nextInt(2)*3;
                    for(int l=6;l<9;l++)
                        {
                            for (int k=0;k<9;k++)
                            {
                                int change_value=table[k][l];
                                table[k][l]=table[k][l+row];
                                table[k][l+row]=change_value;
                            }
                        }
                    break;

                }

            }


        }


    }


    public static int which_one(int row)
    {
        Random rand= new Random();
        switch(row)
        {
        case 0: return row+ rand.nextInt(3);
        case 1: return (int) (row+ Math.pow(-1,rand.nextInt(2)+1)*rand.nextInt(2));
        case 2: return row- rand.nextInt(3);
        case 3: return row+ rand.nextInt(3);
        case 4: return (int) (row+ Math.pow(-1,rand.nextInt(2)+1)*rand.nextInt(2));
        case 5: return row- rand.nextInt(3);
        case 6: return row+ rand.nextInt(3);
        case 7: return (int) (row+ Math.pow(-1,rand.nextInt(2)+1)*rand.nextInt(2));
        case 8: return row- rand.nextInt(3);
        default: return 0;
        }
    }

    public static void remove(int[][] table)
    {
        for(int i=0;i<9;i++)
        {
            for(int j=0; j<9;j++)
            {
                switch(i)
                {
                case 0:
                case 8:
                    if(j==2||j==3||j==5||j==6)
                    {
                        break;
                    }
                    table[j][i]=0;
                    break;

                case 1:
                case 7:
                    if(j==4||j==8)
                    {
                        break;
                    }
                    table[j][i]=0;
                    break;


                case 3:
                case 5:
                case 2:
                case 6:
                    if(j==0||j==8)
                    {
                        break;
                    }
                    table[j][i]=0;
                    break;

                case 4:
                    if(j==1||j==8)
                    {
                        break;
                    }
                    table[j][i]=0;
                    break;
                }
            }
        }
    }

}