SolitaireGUI.java

package org.example;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * The graphical user interface for the Klondike Solitaire game.
 * It handles the display of cards, user interactions, and game messages.
 *
 * @author Mika Edenfield
 */
public class SolitaireGUI {
    private JFrame frame;
    private JButton drawButton;
    private JPanel tableauPanel, foundationPanel, deckPanel, drawnCardContainer, drawnCardPanel, timePanel;
    private GameLogic gameLogic;
    private KlondikeSolitaire klondikeSolitaire;
    private JLabel drawnCardLabel, timeLabel;
    private int selectedColumn = -1;
    private Card selectedCard = null;
    private Card drawnCard = null;
    private Timer timer;
    private long startTime;
    private long elapsedTime;

    /**
     * Constructs the SolitaireGUI, initializing the main frame, panels, buttons,
     * and setting up the initial game display. It also starts the game timer.
     *
     * @param klondikeSolitaire The main game instance.
     */
    public SolitaireGUI(KlondikeSolitaire klondikeSolitaire) {
        this.klondikeSolitaire = klondikeSolitaire;
        this.gameLogic = klondikeSolitaire.getGameLogic();

        frame = new JFrame("Klondike Solitaire");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(1920, 1080);
        frame.setLayout(new BorderLayout());
        frame.setResizable(true);

        // Create the draw button
        drawButton = new JButton("Draw Card");
        drawButton.addActionListener(e -> gameLogic.drawCard());

        // Initialize panels
        tableauPanel = new JPanel(new GridLayout(1, 7));
        foundationPanel = new JPanel(new GridLayout(1, 4));
        drawnCardContainer = new JPanel(new FlowLayout());
        this.timePanel = new JPanel(new FlowLayout(FlowLayout.LEFT));

        // Initialize time label
        this.timeLabel = new JLabel("Time: 00:00");
        this.timePanel.add(this.timeLabel);

        // Add components to the main frame
        frame.add(drawButton, BorderLayout.NORTH);
        frame.add(tableauPanel, BorderLayout.CENTER);
        frame.add(foundationPanel, BorderLayout.SOUTH);
        frame.add(drawnCardContainer, BorderLayout.EAST);
        frame.add(this.timePanel, BorderLayout.WEST);

        updateGUI(false);
        startGameTimer(); // Start the timer when the GUI is initialized
        frame.setVisible(true);
    }

    /**
     * Starts the game timer, recording the start time and initiating updates
     * to the time display every second.
     */
    private void startGameTimer() {
        startTime = System.currentTimeMillis();
        timer = new Timer(1000, new ActionListener() { // Update every 1 second
            @Override
            public void actionPerformed(ActionEvent e) {
                elapsedTime = System.currentTimeMillis() - startTime;
                updateTimeDisplay();
            }
        });
        timer.start();
    }

    /**
     * Stops the game timer if it is currently running.
     */
    private void stopGameTimer() {
        if (timer != null && timer.isRunning()) {
            timer.stop();
        }
    }

    /**
     * Updates the time display label with the elapsed time in MM:SS format.
     */
    private void updateTimeDisplay() {
        long minutes = TimeUnit.MILLISECONDS.toMinutes(elapsedTime) % 60;
        long seconds = TimeUnit.MILLISECONDS.toSeconds(elapsedTime) % 60;
        this.timeLabel.setText(String.format("Time: %02d:%02d", minutes, seconds));
    }

    /**
     * Updates the graphical user interface to reflect the current state of the game,
     * including the tableau, drawn card, and foundation piles.
     *
     * @param normalUpdate Indicates if this is a regular update (true) or an initial setup (false).
     */
    public void updateGUI(boolean normalUpdate) {
        // Clear previous state
        tableauPanel.removeAll();
        drawnCardContainer.removeAll();

        // Drawn card display
        JButton drawnCardButton;
        if (drawnCard != null && drawnCard.isFaceUp()) {
            drawnCardButton = new JButton(drawnCard.toString());
            setCardColor(drawnCardButton, drawnCard);
            drawnCardButton.addActionListener(e -> {
                handleDrawnCardClick();
            });
            drawnCardContainer.add(new JLabel("Drawn Card: "));
            drawnCardContainer.add(drawnCardButton);
        } else {
            drawnCardContainer.add(new JLabel("Drawn Card: "));
            drawnCardContainer.add(new JButton("None"));
        }

        tableauPanel.setLayout(new GridLayout(1, 7));

        for (int i = 0; i < 7; i++) {
            List<Card> columnCards = klondikeSolitaire.getTableau().getColumnCards(i);
            JPanel columnPanel = new JPanel();
            columnPanel.setLayout(new BoxLayout(columnPanel, BoxLayout.Y_AXIS));
            columnPanel.setPreferredSize(new Dimension(100, columnCards.size() * 150));

            if (columnCards.isEmpty()) {
                // Empty column: add a placeholder button
                JButton emptyButton = new JButton("Empty Column");
                emptyButton.setPreferredSize(new Dimension(100, 150));
                int columnIndex = i;
                emptyButton.addActionListener(new ActionListener() {
                    @Override
                    public void actionPerformed(ActionEvent e) {
                        if (selectedCard != null && selectedCard.getRank() == Card.Rank.KING) {
                            if (gameLogic.moveBetweenTableaus(selectedColumn, columnIndex)) {
                                updateColumnPanel(columnIndex);
                                if(selectedColumn != -1) {
                                    updateColumnPanel(selectedColumn);
                                }
                                updateGUI(true);
                                selectedCard = null;
                                selectedColumn = -1;
                            } else {
                                JOptionPane.showMessageDialog(frame, "Invalid move.");
                            }
                        }
                    }
                });
                columnPanel.add(emptyButton);
            } else {
                // Non-empty column: add card buttons
                for (Card card : columnCards) {
                    JButton cardButton;
                    if (card.isFaceUp()) {
                        cardButton = new JButton(card.toString());
                        setCardColor(cardButton, card);
                    } else {
                        cardButton = new JButton("Face Down");
                        cardButton.setForeground(Color.BLACK);
                    }
                    cardButton.setPreferredSize(new Dimension(100, 150));

                    int columnIndex = i;
                    cardButton.addActionListener(new ActionListener() {
                        @Override
                        public void actionPerformed(ActionEvent e) {
                            handleCardClick(columnIndex, card);
                        }
                    });

                    columnPanel.add(cardButton);
                }
            }
            tableauPanel.add(columnPanel);
        }

        tableauPanel.revalidate();
        tableauPanel.repaint();

        // Update foundations state
        foundationPanel.removeAll();
        foundationPanel.setLayout(new GridLayout(2, 4));

        Card.Suit[] suits = Card.Suit.values(); // Get the suit values

        for (int i = 0; i < 4; i++) {
            final int foundationIndex = i;
            List<Card> foundationCards = klondikeSolitaire.getFoundation().getFoundationCards(i);
            String displayText = foundationCards.isEmpty() ? "Empty" : foundationCards.get(foundationCards.size() - 1).toString();
            JButton foundationButton = new JButton(displayText);
            if (!foundationCards.isEmpty()) {
                Card topCard = foundationCards.get(foundationCards.size() - 1);
                setCardColor(foundationButton, topCard);
            }
            foundationButton.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    if (selectedCard != null) {
                        if (gameLogic.moveToFoundation(selectedColumn, foundationIndex)) {
                            if(selectedColumn != -1){
                                updateColumnPanel(selectedColumn);
                            }
                            updateGUI(true);
                            selectedCard = null;
                            selectedColumn = -1;
                        } else {
                            JOptionPane.showMessageDialog(frame, "Invalid move to foundation.");
                        }
                    }
                }
            });
            foundationPanel.add(foundationButton);
        }

        foundationPanel.revalidate();
        foundationPanel.repaint();

        frame.revalidate();
        frame.repaint();
    }

    /**
     * Sets the currently drawn card from the stock.
     *
     * @param card The drawn card.
     */
    public void setDrawnCard(Card card) {
        this.drawnCard = card;
    }

    /**
     * Returns the currently drawn card from the stock.
     *
     * @return The drawn card, or null if no card has been drawn.
     */
    public Card getDrawnCard() {
        return drawnCard;
    }

    /**
     * Sets the color of a card button based on the suit of the card.
     * Red for Hearts and Diamonds, Black for Clubs and Spades.
     *
     * @param cardButton The button representing the card.
     * @param card       The card associated with the button.
     */
    private void setCardColor(JButton cardButton, Card card) {
        if (card.getSuit() == Card.Suit.HEARTS || card.getSuit() == Card.Suit.DIAMONDS) {
            cardButton.setForeground(Color.RED);
        } else {
            cardButton.setForeground(Color.BLACK);
        }
    }

    /**
     * Handles the click event on the drawn card. If a card is drawn, it becomes the
     * currently selected card for potential moves.
     */
    private void handleDrawnCardClick() {
        if (drawnCard != null) {
            selectedCard = drawnCard;
        }
    }

    /**
     * Handles the click event on a card in the tableau. It manages the selection
     * of cards for moving and initiates move attempts through the game logic.
     *
     * @param columnIndex The index of the column where the card was clicked.
     * @param card        The clicked card.
     */
    private void handleCardClick(int columnIndex, Card card) {

        List<Card> columnCards = klondikeSolitaire.getTableau().getColumnCards(columnIndex);

        if (selectedCard == null) {
            if (columnCards.contains(card) && card.isFaceUp()) {
                selectedCard = card;
                selectedColumn = columnIndex;
            }
        } else {
            if (selectedCard == drawnCard) {
                if (gameLogic.moveBetweenTableaus(-1, columnIndex)) {
                    SwingUtilities.invokeLater(() -> {
                        updateColumnPanel(columnIndex);
                        updateGUI(true);
                    });
                } else {
                    JLabel errorLabel = new JLabel("Invalid Move, Try Again");
                    JOptionPane.showMessageDialog(frame, errorLabel);
                }

                selectedCard = null;
                selectedColumn = -1;
                return;
            }

            Card movedCard = selectedCard;
            if (gameLogic.moveBetweenTableaus(selectedColumn, columnIndex)) {
                SwingUtilities.invokeLater(() -> {
                    updateColumnPanel(columnIndex);
                    if (selectedColumn != -1) {
                        updateColumnPanel(selectedColumn);
                    }
                    SwingUtilities.invokeLater(() -> {
                        updateGUI(true);
                    });
                });
            } else {
                JLabel errorLabel = new JLabel("Invalid Move, Try Again");
                JOptionPane.showMessageDialog(frame, errorLabel);
            }

            selectedCard = null;
            selectedColumn = -1;
        }
    }

    /**
     * Updates the visual representation of a single tableau column.
     *
     * @param columnIndex The index of the column to update.
     */
    public void updateColumnPanel(int columnIndex) {
        JPanel columnPanel = (JPanel) tableauPanel.getComponent(columnIndex);
        columnPanel.removeAll();
        List<Card> columnCards = klondikeSolitaire.getTableau().getColumnCards(columnIndex);

        if (columnCards.isEmpty()) {
            JButton emptyButton = new JButton("Empty Column");
            emptyButton.setPreferredSize(new Dimension(100, 150));
            emptyButton.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    if (selectedCard != null && selectedCard.getRank() == Card.Rank.KING) {
                        if (gameLogic.moveBetweenTableaus(selectedColumn, columnIndex)) {
                            updateColumnPanel(columnIndex);
                            if(selectedColumn != -1) {
                                updateColumnPanel(selectedColumn);
                            }
                            updateGUI(true);
                            selectedCard = null;
                            selectedColumn = -1;
                        } else {
                            JOptionPane.showMessageDialog(frame, "Invalid move.");
                        }
                    }
                }
            });
            columnPanel.add(emptyButton);
        } else {
            for (int i = 0; i < columnCards.size(); i++) {
                Card card = columnCards.get(i);
                JButton cardButton;
                if (card.isFaceUp()) {
                    cardButton = new JButton(card.toString());
                    setCardColor(cardButton, card);
                } else {
                    cardButton = new JButton("Face Down");
                    cardButton.setForeground(Color.BLACK);
                }

                if (i == columnCards.size() - 1) {
                    cardButton.setPreferredSize(new Dimension(100, 150));
                } else {
                    cardButton.setPreferredSize(new Dimension(100, 30));
                }

                int colIndex = columnIndex;
                cardButton.addActionListener(e -> handleCardClick(colIndex, card));

                columnPanel.add(cardButton);
                columnPanel.add(Box.createVerticalStrut(5));
            }
        }

        columnPanel.revalidate();
        columnPanel.repaint();
    }

    /**
     * Handles the win condition of the game. Stops the timer, displays a
     * congratulatory message with the final time, and offers options to
     * play again or close the game.
     */
    public void handleWinCondition() {
        stopGameTimer(); // Stop the timer when the game is won
        long minutes = TimeUnit.MILLISECONDS.toMinutes(elapsedTime) % 60;
        long seconds = TimeUnit.MILLISECONDS.toSeconds(elapsedTime) % 60;
        String timeString = String.format("%02d:%02d", minutes, seconds);
        String message = "Congratulations!\nYour time was " + timeString + "\nPlay Again?";
        int option = JOptionPane.showConfirmDialog(
                frame,
                message,
                "You Won!",
                JOptionPane.YES_NO_OPTION
        );

        if (option == JOptionPane.YES_OPTION) {
            restartGame();
        } else if (option == JOptionPane.NO_OPTION) {
            frame.dispose(); // Close the game window
        }
    }

    /**
     * Restarts the game by creating a new KlondikeSolitaire instance and
     * closing the current game window.
     */
    private void restartGame() {
        stopGameTimer(); // Ensure the timer is stopped
        new KlondikeSolitaire();
        frame.dispose(); // Close the current game window
    }

    /**
     * Prints a debug message to the console.
     *
     * @param message The message to print.
     */
    private void debug(String message) {
        System.out.println("[DEBUG] " + message);
    }

    /**
     * Returns the currently selected card by the user.
     *
     * @return The selected Card object, or null if no card is selected.
     */
    public Card getSelectedCard(){
        return selectedCard;
    }

    /**
     * Sets the GameLogic instance for this GUI.
     *
     * @param gameLogic The GameLogic object.
     */
    public void setGameLogic(GameLogic gameLogic){
        this.gameLogic = gameLogic;
    }

    /**
     * Main method to start the Solitaire GUI (although the game is initiated from KlondikeSolitaire).
     *
     * @param args Command line arguments (not used).
     */
    public static void main(String[] args) {
        new KlondikeSolitaire();
    }
}