SudokuGUI.java

import javax.swing.*;
import javax.swing.border.*;
import java.awt.*;
import java.awt.event.*;

import java.util.Stack;
import java.util.Observer;
import java.util.Observable;



/**
* SudokuGUI
* This class is the GUI for the Sudoku game. It contains the main method and the GUI elements.
* The class extends JPanel and implements Observer to observe changes in the game.
*
* @author Arun Kumar Sekar

* @version January 2024
*/
@SuppressWarnings({ "deprecation", "serial" })
    public class SudokuGUI extends JPanel implements Observer {
    
        private int GRID_SIZE;//The size of the grid
        private Sudoku theGame;
        private int moveCount;//The number of moves made
        
        private Stack<Assign> uStack;
        private Stack<Assign> rStack;
        
        private JButton[][] cells; //Array of buttons to represent the cells
        private JButton saveButton, loadButton, clearButton, undoButton, redoButton, helpButton, quitButton;
       
        private JTextArea statusArea;
        private JTextArea moveHistoryArea;
        
        private JLabel moveCountLabel;
        private JLabel remainingMovesLabel;
        
        private DifficultyManager difficultyManager;

    /**
    * 
    * SudokuGUI
    * This is the constructor for the SudokuGUI class.
    * Initializes the Sudoku game model and sets up the graphical user interface components.
    * This includes creating the game grid, setting up control buttons (Save, Load, Clear, Undo, Redo, Help, Quit),
    * It also sets up the stacks for undo and redo.Constructor for the SudokuGUI class.
    *    
    */     

    public SudokuGUI() {
        theGame = new Sudoku();
        difficultyManager = new DifficultyManager();    
        this.GRID_SIZE = theGame.getGameSize(); // Sets the grid size based on the game file automatically

        //Setting up the difficulty Label
        difficultyManager = new DifficultyManager();
        remainingMovesLabel = new JLabel("");
        remainingMovesLabel.setHorizontalAlignment(JLabel.CENTER);
        remainingMovesLabel.setBorder(new LineBorder(Color.BLACK));
       
        //Setting up the move count Label
        moveCount = 0;
        moveCountLabel = new JLabel("Moves: 0");
        moveCountLabel.setHorizontalAlignment(JLabel.CENTER);
        moveCountLabel.setBorder(new LineBorder(Color.BLACK));
              
        // Setting up the border and padding for the main game grid
        Border roundedCornerBorder = new LineBorder(Color.BLACK, 1, true);
        Border paddingBorder = new EmptyBorder(10, 10, 10, 10);
        Border compoundBorder = new CompoundBorder(roundedCornerBorder, paddingBorder);
        
        // Setting up the main game grid
        JPanel gridPanel = new JPanel(new GridLayout(GRID_SIZE, GRID_SIZE));
        gridPanel.setBorder(compoundBorder);
        cells = new JButton[GRID_SIZE][GRID_SIZE];
        for (int row = 0; row < GRID_SIZE; row++) {
            for (int col = 0; col < GRID_SIZE; col++) {
                cells[row][col] = createCellButton(row, col);
                cells[row][col].setBorder(new RoundedBorder(10));
                gridPanel.add(cells[row][col]);
            }
        }

        // Setting up the buttons
        saveButton = new JButton("Save");
        saveButton.addActionListener(new ActionListener() {
          @Override
          public void actionPerformed(ActionEvent ae) {
          saveGame();
         }
        });
        
        loadButton = new JButton("Load");
        loadButton.addActionListener(new ActionListener() {
          @Override
          public void actionPerformed(ActionEvent ae) {
          loadGame();
         }
        });
        
        clearButton = new JButton("Clear");
        clearButton.addActionListener(new ActionListener() {
          @Override
          public void actionPerformed(ActionEvent ae) {
          clearGame();
         }
        });

        undoButton = new JButton("Undo");
        undoButton.addActionListener(new ActionListener() {
          @Override
          public void actionPerformed(ActionEvent ae) {
          undoMove();
         }
        });
        
        redoButton = new JButton("Redo");
        redoButton.addActionListener(new ActionListener() {
          @Override
          public void actionPerformed(ActionEvent ae) {
          redoMove();
         }
        });
        
        helpButton = new JButton("Help");
        helpButton.addActionListener(new ActionListener() {
         @Override
         public void actionPerformed(ActionEvent ae) {
         new HelpClass().displayHelpDialog();
         }
        });
       
        quitButton = new JButton("Quit");
        quitButton.addActionListener(new ActionListener() {
          @Override
          public void actionPerformed(ActionEvent ae) {
          System.exit(0);
         }
        });
        
        // Customize buttons with rounded corners
        saveButton.setBorder(new RoundedBorder(20));
        loadButton.setBorder(new RoundedBorder(20));
        clearButton.setBorder(new RoundedBorder(20));
        undoButton.setBorder(new RoundedBorder(20));
        redoButton.setBorder(new RoundedBorder(20));
        helpButton.setBorder(new RoundedBorder(20));
        quitButton.setBorder(new RoundedBorder(20));
        

        // Setting up the button panel
        JPanel buttonPanel = new JPanel();
        buttonPanel.setBorder(paddingBorder);
        buttonPanel.add(saveButton);
        buttonPanel.add(loadButton);
        buttonPanel.add(clearButton);
        buttonPanel.add(undoButton);
        buttonPanel.add(redoButton);
        buttonPanel.add(helpButton);
        buttonPanel.add(quitButton);
        
        buttonPanel.add(moveCountLabel);
        buttonPanel.add(remainingMovesLabel);

        // Setting up the status display area
        statusArea = new JTextArea(2, 20);
        statusArea.setEditable(false);
        JPanel statusPanel = new JPanel(new BorderLayout());
        statusPanel.add(new JScrollPane(statusArea), BorderLayout.CENTER);
        statusPanel.setBorder(BorderFactory.createTitledBorder(compoundBorder, "Instructions"));

        // Setting up the move history area
        moveHistoryArea = new JTextArea(5, 20);
        moveHistoryArea.setEditable(false);
        JPanel moveHistoryPanel = new JPanel(new BorderLayout());
        moveHistoryPanel.add(new JScrollPane(moveHistoryArea), BorderLayout.CENTER);
        moveHistoryPanel.setBorder(BorderFactory.createTitledBorder(compoundBorder, "Keeping Track!"));

        // Setting up the main panel layout
        setLayout(new BorderLayout(10, 10)); 
        add(statusPanel, BorderLayout.NORTH);
        add(gridPanel, BorderLayout.CENTER);
        add(moveHistoryPanel, BorderLayout.EAST);
        add(buttonPanel, BorderLayout.SOUTH);

        // Initialize the stacks
        uStack = new Stack<>();
        rStack = new Stack<>();

        // Observing the changes
        for (int row = 0; row < GRID_SIZE; row++) {
            for (int col = 0; col < GRID_SIZE; col++) {
                theGame.getMoves()[row][col].addObserver(this);
            }
        }
              
        // Display the initial state of the game
        displayGame();
        
        // Update the cell appearance
        cellGraphics();
        
        //updating the remaining moves label
        updateRemainingMovesLabel();
    }
    
    
    /**
    * 
    * This class is used to create a rounded border 
    * It is used as a helper class for the SudokuGUI class.
    * The Rounded border ovverides the default border 
    *
    */  

    class RoundedBorder implements Border {
        private int radius;
        RoundedBorder(int radius) {
            this.radius = radius;
        }
        /**
        * 
        * It returns the insets of the border.
        * 
        * @param c The component for which this border insets value applies
        * @return The insets of the border
        *       
        */  
        @Override
        public Insets getBorderInsets(Component c) {
            return new Insets(this.radius+1, this.radius+1, this.radius+2, this.radius);
        }
        /**
        * 
        * Says whether the border is opaque or not.
        * 
        * @return True if the border is opaque, false otherwise
        *      
        */ 
        @Override
        public boolean isBorderOpaque() {
            return false;
        }
        /**
        * 
        * This method paints the border of the specific component.
        * 
        * @param c The component for which this border is being painted
        * @param g The graphics context to use for painting the border
        * @param x,y The x and y position of the painted border
        * @param width,height The width and height of the painted border
        *       
        */ 
        @Override
        public void paintBorder(Component c, Graphics g, int x, int y, int width, int height) {
            g.drawRoundRect(x, y, width-1, height-1, radius, radius);
        }
    }

    /**
    * createCellButton
    * This method creates a new cell for the Sudoku grid.
    * 
    * @param row The row number of the button
    * @param col The column number of the button

    * @return A JButton configured corresponding to the row and column
    */
    private JButton createCellButton(int row, int col) {
        JButton button = new JButton();
        button.addActionListener(e -> cellSelect(row, col));
        return button;
    }


    /**
    * moveCountLabel
    * Updates the label that displays the current move count.
    */
    private void moveCountLabel() {
        moveCountLabel.setText("Moves: " + moveCount);
    }
    
   /**
   * initializeDifficulty 
   * Initializes the select difficulty frame of the Sudoku game.
   * This method sets the difficulty and updates the label displaying the remaining moves.
   */
    public void initializeDifficulty() {
        selectDifficulty();
        updateRemainingMovesLabel();
    }
    
    /**
   * latestCellValue
   * Updates the value of the the specific cell
   * Sets the text to the current value
   * Also checks if the cell is fillable or not
   * 
   * @param row The row number of the cell
   * @param col The column number of the cell
   * 
   */ 
    private void latestCellValue(int row, int col) {
        JButton cellButton = cells[row][col];
        String cellValue = theGame.getIndividualMove(row, col);
        cellButton.setText(cellValue.equals("-") ? "" : cellValue);
        cellButton.setEnabled(isCellFillable(row, col));
    }

    /**
    * 
    * cellGraphics 
    * This method defines graphical properties of all cells in the Sudoku grid.
    * This includes the background color, text color, font, and border.
    * 
    */
    private void cellGraphics() {
        for (int row = 0; row < GRID_SIZE; row++) {
            for (int col = 0; col < GRID_SIZE; col++) {
                JButton cell = cells[row][col];
                if (this.isCellFillable(row, col)) {
                    cell.setBackground(Color.GREEN);
                } else {
                    cell.setBackground(Color.WHITE);
                }
                cell.setForeground(Color.BLACK);
                cell.setFont(new Font("Manrope", Font.BOLD, 20));
                cell.setBorder(new RoundedBorder(10));
            }
        }
    }
  
    /**
   * 
   * replayGame
   * Asks the user to play another game upon successfully solving the puzzle.
   * If the user chooses to play again, the game state is reset. Otherwise, the application exits.
   *
   */    
    private void replayGame() {
        int playAgainOption = JOptionPane.showConfirmDialog(this, "Yaaaayyyyyyyyy!!!!!!, you solved the puzzle\nWould you like to play again?", "Play Again?", JOptionPane.YES_NO_OPTION);
        if (playAgainOption == JOptionPane.YES_OPTION) {
            clearGame();
        } else {
        System.exit(0); 
        }
    }

    /**
    * 
    * displayGame
    * Updates the display of the entire game grid based on the current state of the game.
    * Each cell's text is set to display the value of the corresponding cell in the game model.
    * Once the grid is updated, the method checks if the game has been won. If so, it disables all cells.
    * 
    *
    */
    public void displayGame() {
        for (int row = 0; row < GRID_SIZE; row++) {
            for (int col = 0; col < GRID_SIZE; col++) {
                JButton cellButton = cells[row][col];
                String cellValue = theGame.getIndividualMove(row, col);
                cellButton.setText(cellValue.equals("-") ? "" : cellValue);
                cellButton.setEnabled(isCellFillable(row, col)); // Enable based on fillability
            }
        }    
        // Check if the game is solved and prompt to play again
        if (theGame.checkWin()) {
            for (JButton[] cellRow : cells) {
                for (JButton cell : cellRow) {
                    cell.setEnabled(false); // Disable all cells if the game is won
                }
            }
            replayGame();
        }
    }


    
    /**
    * CellSelect
    * Handles user interaction when a cell is selected in the Sudoku grid.
    * If a cell is fillable, it prompts the user to enter a number for the cell.
    * Validates the input to ensure it's a valid number for the specific Sudoku grid[9x9 or 4x4].
    * 
    * Also checks against the difficulty settings to limit the moves
    *
    * @param row The row number of the clicked cell.
    * @param col The column number of the clicked cell.
    *
    */
    private void cellSelect(int row, int col) {
        if (!isCellFillable(row, col)) {
            statusArea.setText("This cell cannot be changed.");
            return;
        }

        int maxValidNumber = GRID_SIZE == 9 ? 9 : 4;
        String number = JOptionPane.showInputDialog(this, "Enter a number for this box:(1-" + maxValidNumber + "): ");

        // Validate the input number
        while (number != null && !number.matches("[1-" + maxValidNumber + "]")) {
            statusArea.setText("Invalid input. Please enter a number between 1 and " + maxValidNumber + ".");
            number = JOptionPane.showInputDialog(this, "Enter a number for this box (1-" + maxValidNumber + "):");
        }

        if (number != null && number.matches("[1-" + maxValidNumber + "]")) {
            String prevState = theGame.getIndividualMove(row, col);
            // Check if the number is already in the same row or column
            boolean numberExists = isNumberInRowOrColumn(row, col, number);
            if (theGame.makeMove(Integer.toString(row), Integer.toString(col), number)) {
                uStack.push(new Assign(theGame, row, col, number, prevState));
                cells[row][col].setText(number);
                cells[row][col].setForeground(Color.BLACK);
                cells[row][col].setEnabled(true); 
                displayGame();
                moveCount++;
                moveCountLabel();
                updateMoveHistory("Move made at row " + row + ", column " + col + " = " + number + ". Total moves: " + moveCount);

                if (numberExists) {
                    statusArea.setText("Number " + number + " already exists in the same row or column. You can undo this.");
                    cells[row][col].setForeground(Color.RED);
                } else {
                    updateMoveHistory("Move made at row " + row + ", column " + col + " = " + number);
                    statusArea.setText("Valid Move");
                    cells[row][col].repaint();
                }

            } else {
                statusArea.setText("Invalid move. Please try again.");
            }
        }
    
        if (difficultyManager.canMakeMove(moveCount, GRID_SIZE)) {
            updateRemainingMovesLabel();
        } else {
            JOptionPane.showMessageDialog(this, "No more moves allowed on Hard difficulty.", "Move Limit Reached!!", JOptionPane.ERROR_MESSAGE);
            return;
        }
    
    }   

    /**
    * Checks if a given number exists in the same row or column as the specified cell.
    * 
    * @param row    The row of the cell being checked.
    * @param col    The column of the cell being checked.
    * @param number The number to check for in the same row or column.
    *
    * @return true if the number exists in the same row or column, false otherwise.
    */

    private boolean isNumberInRowOrColumn(int row, int col, String number) {
    
        for (int c = 0; c < GRID_SIZE; c++) {
            if (c != col) { 
                String cellValue = theGame.getIndividualMove(row, c);
                if (number.equals(cellValue)) {
                    return true; // Number found in the same column
                }
            }
        }
        for (int r = 0; r < GRID_SIZE; r++) {
            if (r != row) { 
                String cellValue = theGame.getIndividualMove(r, col);
                if (number.equals(cellValue)) {
                    return true; // Number found in the same column
                }
            }
        }
        return false; // Number not found in the same row or column
    }

    /**
    * Saves the current game state to a file using the FileDriver class.
    */
    private void saveGame() {
        FileDriver.saveGame(theGame, GRID_SIZE, statusArea);
    }

    /**
    * loads the saved game state from a file using the FileDriver class.
    */
    private void loadGame() {
        FileDriver.loadGame(theGame, GRID_SIZE, statusArea, this);
    }

    /**
     * clearGame
     * This method resets the current game to a new game
     * It resets all the stacks 
     * Also the UI and move counts are updated to a new game
     *  
     */
    private void clearGame() {
        theGame = new Sudoku(); // Reset the game
    
        uStack.clear(); // Clear the move history
        rStack.clear();
    
        displayGame(); // Update the UI
        statusArea.setText("Game cleared.");
    
        moveCount = 0;
        moveCountLabel();
    }

    /**
     * undoMove
     * This method performs the undo move resulting in the poping the last-in value in the ustack
     * It will also push the move back onto the redo stack in case the user wants to redo the move again
     * If there are no moves(empty stack), the method prints out "No moves to undo"
     * Updates the move count, the move history area and the status area
     * 
     */
    private void undoMove() {
        if (uStack.isEmpty())
        {
            statusArea.setText("No moves to undo.");               
        } else {
            Assign top = uStack.pop();
            rStack.push(top); // Save the undone move for redoing
    
            theGame.makeMove(Integer.toString(top.getRow()), Integer.toString(top.getCol()), top.getPrevMove());
            displayGame();
            cellGraphics();
            
            statusArea.setText("Move undone.");
            moveCount--;
            moveCountLabel();
            updateMoveHistory("Undo made at row " + top.getRow() + ", column " + top.getCol() + ". Total moves: " + moveCount);   
        }   
    }
    
      /**
     * 
     * This method implement redoMove to pop from value from the rStack if there are any and make the move again
     * It will also push the move back onto the undo stack in case the user wants to undo the move again
     * If there are no moves(empty stack), the method prints out "No moves to redo"
     * Updates the move count, the move history area and the status area
     * 
     */
    private void redoMove() {
        if (!rStack.isEmpty()) 
        {
            Assign top = rStack.pop();
            uStack.push(top); // Push the redone move back onto the undo stack
            
            theGame.makeMove(Integer.toString(top.getRow()), Integer.toString(top.getCol()), top.getNumber());
            displayGame();
            cellGraphics();
            
            
            statusArea.setText("Move redone.");
            moveCount++;
            moveCountLabel();
            updateMoveHistory("Redo made at row " + top.getRow() + ", column " + top.getCol() + ". Total moves: " + moveCount);   
        } else {
            statusArea.setText("No moves to redo.");
        }
    }
       
    /**
     * updateMoveHistory
     * This method updates the move history area with the latest move
     * 
     * @param move
     */
    private void updateMoveHistory(String move) {
        moveHistoryArea.append(move + "\n"); // Append the move to the text area
        moveHistoryArea.setCaretPosition(moveHistoryArea.getDocument().getLength()); // Auto-scroll to the latest move
    }
    
    /**
     * isCellFillable
     * This method checks if the cell is fillable or not
     * 
     * @param row
     * @param col
     * @return boolean true is the cell is fillable, false otherwise
     */
    public boolean isCellFillable(int row, int col) {
        return theGame.getMoves()[row][col].getFillable();
    }

    /**
     * selectDifficulty
     * This method displays the difficulty selection frame
     * It sets the difficulty based on the user selection [EASY, HARD]
     * Uses the difficulty manager class to set the moves based on the difficulty
     * calls the updateRemainingMovesLabel() to update the remaining moves label
     */
    private void selectDifficulty() {
        Object[] options = {"Easy", "Hard"};
        int choice = JOptionPane.showOptionDialog(this, 
            "Select Difficulty Level:", 
            "Difficulty Selection", 
            JOptionPane.DEFAULT_OPTION, 
            JOptionPane.INFORMATION_MESSAGE, 
            null, options, options[0]);
    
        if (choice == 0) {
            difficultyManager.setDifficulty(DifficultyManager.Difficulty.EASY);
        } else if (choice == 1) {
            difficultyManager.setDifficulty(DifficultyManager.Difficulty.HARD);
        }
        updateRemainingMovesLabel();
        clearGame();
    }
    

    /**
     * updateRemainingMovesLabel
     * This method updates the remaining moves label based on the difficulty
     * If the difficulty is hard, it will display the remaining moves
     * If the difficulty is easy, it will display unlimited moves
     */
    private void updateRemainingMovesLabel() {
        if (difficultyManager.getDifficulty() == DifficultyManager.Difficulty.HARD) {
            int remainingMoves = difficultyManager.getRemainingMoves(moveCount, GRID_SIZE);
            remainingMovesLabel.setText("Remaining Moves: " + remainingMoves);
        } else {
            remainingMovesLabel.setText("Unlimited Moves");
        }
    }
    
    /**
    * Called whenever an observed object is changed. This method is part of the Observer implementation.
    * It updates the value displayed in a cell if the corresponding Observable object (a move) has changed.
    * 
    * @param o The observable object.
    * @param arg An argument passed to the notifyObservers method (not used here).
    */
    @Override
    public void update(Observable o, Object arg) {
        // This method is called whenever the observed object is changed
        for (int row = 0; row < GRID_SIZE; row++) {
            for (int col = 0; col < GRID_SIZE; col++) {
                if (o == theGame.getMoves()[row][col]) {
                    latestCellValue(row, col); // Update the specific cell
                }
            }
        }
    }
    /**
     * main method
     * This is the main method of the SudokuGUI class
     * It creates a new JFrame and adds the SudokuGUI to the frame
     * 
     */ 
    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> {
            JFrame frame = new JFrame("Sudoku");
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            SudokuGUI sudokuGUI = new SudokuGUI();
            sudokuGUI.initializeDifficulty(); 
            frame.getContentPane().add(sudokuGUI);
            frame.pack();
            frame.setVisible(true);
        });
    }
}//end of class SudoKuGUI