import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.Set;
import java.util.HashSet;

public class HangedGameGUI {
    private static final int MAX_LIVES = 12;

    // Game variables
    private String word;  
    private Set<Character> guessedLetters;
    private int lives;
    private String difficulty;  // "easy", "medium", "hard"

    // Timer and scoring
    private TimerManager timerManager;

    // GUI components
    private JFrame frameMenu;
    private JFrame frameGame;
    private JLabel wordLabel;
    private JLabel livesLabel;
    private JLabel messageLabel;
    private JTextField letterField;
    private JButton guessButton;
    private JPanel hangmanPanel;

    private JButton easyButton;
    private JButton mediumButton;
    private JButton hardButton;

    public HangedGameGUI() {
        WordSelector.loadWordsForDifficulty("easy", "motsFacile.txt");
        WordSelector.loadWordsForDifficulty("medium", "motsMoyen.txt");
        WordSelector.loadWordsForDifficulty("hard", "motsDifficiles.txt");

        guessedLetters = new HashSet<>();
        lives = MAX_LIVES;
        timerManager = new TimerManager();

        initializeMenuGUI();
    }

    private void initializeMenuGUI() {
        frameMenu = new JFrame("Jeu du Pendu — Choix de difficulté");
        frameMenu.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frameMenu.setSize(400, 200);
        frameMenu.setLayout(new BorderLayout());

        JLabel prompt = new JLabel("Sélectionnez une difficulté :", JLabel.CENTER);
        prompt.setFont(new Font("Arial", Font.BOLD, 16));
        frameMenu.add(prompt, BorderLayout.NORTH);

        JPanel buttonPanel = new JPanel(new GridLayout(3, 1, 5, 5));
        easyButton = new JButton("Easy");
        mediumButton = new JButton("Medium");
        hardButton = new JButton("Hard");
        buttonPanel.add(easyButton);
        buttonPanel.add(mediumButton);
        buttonPanel.add(hardButton);
        frameMenu.add(buttonPanel, BorderLayout.CENTER);

        setupMenuEvents();

        frameMenu.setLocationRelativeTo(null);
        frameMenu.setVisible(true);
    }

    private void setupMenuEvents() {
        easyButton.addActionListener(e -> {
            difficulty = "easy";
            startNewGame();
        });
        mediumButton.addActionListener(e -> {
            difficulty = "medium";
            startNewGame();
        });
        hardButton.addActionListener(e -> {
            difficulty = "hard";
            startNewGame();
        });
    }

    private void startNewGame() {
        frameMenu.setVisible(false);

        guessedLetters.clear();
        lives = MAX_LIVES;

        word = WordSelector.pickWord(difficulty);

        initializeGameGUI();

        timerManager.start();
    }

    private void initializeGameGUI() {
        frameGame = new JFrame("Jeu du Pendu — " + difficulty);
        frameGame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frameGame.setSize(600, 400);
        frameGame.setLayout(new BorderLayout());

        JPanel topPanel = new JPanel(new GridLayout(3, 1));
        wordLabel = new JLabel("", JLabel.CENTER);
        wordLabel.setFont(new Font("Arial", Font.BOLD, 24));
        updateWordDisplay();

        livesLabel = new JLabel("Lives: " + lives + " / " + MAX_LIVES, JLabel.CENTER);
        livesLabel.setFont(new Font("Arial", Font.PLAIN, 16));

        messageLabel = new JLabel("Devinez le mot !", JLabel.CENTER);
        messageLabel.setFont(new Font("Arial", Font.ITALIC, 14));

        topPanel.add(wordLabel);
        topPanel.add(livesLabel);
        topPanel.add(messageLabel);

        hangmanPanel = new JPanel() {
            @Override
            protected void paintComponent(Graphics g) {
                super.paintComponent(g);
                drawHangman(g);
            }
        };
        hangmanPanel.setPreferredSize(new Dimension(300, 300));
        hangmanPanel.setBackground(Color.WHITE);

        JPanel inputPanel = new JPanel(new FlowLayout());
        JLabel inputLabel = new JLabel("Enter a letter:");
        letterField = new JTextField(2);
        letterField.setFont(new Font("Arial", Font.BOLD, 18));
        guessButton = new JButton("Guess");

        inputPanel.add(inputLabel);
        inputPanel.add(letterField);
        inputPanel.add(guessButton);

        frameGame.add(topPanel, BorderLayout.NORTH);
        frameGame.add(hangmanPanel, BorderLayout.CENTER);
        frameGame.add(inputPanel, BorderLayout.SOUTH);

        setupGameEvents();

        frameGame.setLocationRelativeTo(null);
        frameGame.setVisible(true);
    }

    private void setupGameEvents() {
        guessButton.addActionListener(e -> processGuess());
        letterField.addActionListener(e -> processGuess());
    }

    private void processGuess() {
        String input = letterField.getText().toLowerCase().trim();
        letterField.setText("");

        if (input.length() != 1 || !Character.isLetter(input.charAt(0))) {
            messageLabel.setText("Please enter a single letter.");
            return;
        }

        char letter = input.charAt(0);
        if (guessedLetters.contains(letter)) {
            messageLabel.setText("You already guessed that letter.");
            return;
        }

        guessedLetters.add(letter);

        if (!word.contains(String.valueOf(letter))) {
            lives--;
            messageLabel.setText("Wrong letter! Lives left: " + lives);
        } else {
            messageLabel.setText("Good guess!");
        }

        updateWordDisplay();
        livesLabel.setText("Lives: " + lives + " / " + MAX_LIVES);
        hangmanPanel.repaint();

        checkGameEnd();
    }

    private void updateWordDisplay() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < word.length(); i++) {
            char c = word.charAt(i);
            if (c == ' ') {
                sb.append("  ");
            } else if (guessedLetters.contains(c)) {
                sb.append(c).append(" ");
            } else {
                sb.append("_ ");
            }
        }
        wordLabel.setText(sb.toString());
    }

    private void drawHangman(Graphics g) {
        int errors = MAX_LIVES - lives;
        g.setColor(Color.BLACK);
        if (errors >= 1) g.drawLine(50, 250, 150, 250);
        if (errors >= 2) g.drawLine(100, 250, 100, 50);
        if (errors >= 3) g.drawLine(100, 50, 200, 50);
        if (errors >= 4) g.drawLine(200, 50, 200, 80);
        if (errors >= 5) g.drawOval(185, 80, 30, 30);
        if (errors >= 6) g.drawLine(200, 110, 200, 160);
        if (errors >= 7) g.drawLine(200, 120, 180, 140);
        if (errors >= 8) g.drawLine(200, 120, 220, 140);
        if (errors >= 9) g.drawLine(200, 160, 180, 190);
        if (errors >= 10) g.drawLine(200, 160, 220, 190);
        if (errors >= 11) {
            g.drawArc(190, 90, 5, 5, 0, 180);
            g.drawArc(205, 90, 5, 5, 0, 180);
            g.drawArc(190, 105, 15, 8, 0, -180);
        }
    }

    private void checkGameEnd() {
        boolean won = GameLogic.isWordGuessed(word, guessedLetters);
        if (lives <= 0 || won) {
            endGame(won);
        }
    }

    private void endGame(boolean won) {
        guessButton.setEnabled(false);
        letterField.setEnabled(false);

        long elapsedMillis = timerManager.getElapsedTimeMillis();
        int errors = MAX_LIVES - lives;
        int score = ScoreManager.calculateScore(errors, elapsedMillis, difficulty);

        String message;
        if (won) {
            message = "You win! Word: " + word + "\nLives left: " + lives + "\nScore: " + score;
            JOptionPane.showMessageDialog(frameGame, message, "Victory", JOptionPane.INFORMATION_MESSAGE);
        } else {
            message = "You lose! Word: " + word + "\nScore: " + score;
            JOptionPane.showMessageDialog(frameGame, message, "Defeat", JOptionPane.ERROR_MESSAGE);
        }

        int choice = JOptionPane.showConfirmDialog(frameGame, "Play again?", "Replay", JOptionPane.YES_NO_OPTION);
        if (choice == JOptionPane.YES_OPTION) {
            frameGame.dispose();
            frameMenu.setVisible(true);
        } else {
            System.exit(0);
        }
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(HangedGameGUI::new);
    }
}