package org.simon.model;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

/**
 * Modelo puro do jogo Simon (sem UI). Responsável pela sequência, validação e estado básico.
 */
public final class SimonGame {
    private final List<Integer> sequence = new ArrayList<>();
    private final Random random;
    private boolean strictMode = false;

    public SimonGame() {
        this(new Random());
    }

    public SimonGame(Random rnd) {
        this.random = rnd;
    }

    public void reset() {
        sequence.clear();
    }

    public int size() {
        return sequence.size();
    }

    public List<Integer> getSequence() {
        return List.copyOf(sequence);
    }

    public int addRandomStep(int maxButtons) {
        if (maxButtons <= 0) throw new IllegalArgumentException("maxButtons must be > 0");
        int next = random.nextInt(maxButtons);
        sequence.add(next);
        return next;
    }

    /**
     * Valida o input do jogador passo a passo.
     * @param inputSequence lista com os inputs do jogador para comparar com a sequência.
     * @return true se todos os inputs conferirem até o tamanho de inputSequence.
     */
    public boolean validatePrefix(List<Integer> inputSequence) {
        if (inputSequence == null) throw new IllegalArgumentException("inputSequence null");
        if (inputSequence.size() > sequence.size()) return false;
        for (int i = 0; i < inputSequence.size(); i++) {
            if (!sequence.get(i).equals(inputSequence.get(i))) return false;
        }
        return true;
    }

    public boolean isStrictMode() {
        return strictMode;
    }

    public void setStrictMode(boolean strictMode) {
        this.strictMode = strictMode;
    }
}

package org.simon.controller;

import org.simon.model.SimonGame;
import org.simon.view.SimonView;

import javax.swing.*;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

/**
 * Controller: coordena fluxo entre modelo e visão.
 * Usa ScheduledExecutorService para tocar a sequência sem bloquear a EDT.
 */
public final class SimonController {
    private final SimonGame model;
    private final SimonView view;
    private final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
    private final ExecutorService uiExecutor = Executors.newSingleThreadExecutor();
    private final int maxButtons = 4;

    private List<Integer> playerBuffer = new ArrayList<>();
    private boolean playerTurn = false;

    public SimonController(SimonGame model, SimonView view) {
        this.model = model;
        this.view = view;
        attachViewListeners();
    }

    private void attachViewListeners() {
        view.setStartAction(e -> start());
        view.setButtonPressedListener(index -> onPlayerPress(index));
        view.setStrictModeListener(on -> model.setStrictMode(on));
        view.setResetAction(e -> reset());
    }

    public void start() {
        view.lockButtons(true);
        resetRound();
        nextRound();
    }

    private void resetRound() {
        playerBuffer.clear();
        playerTurn = false;
    }

    private void nextRound() {
        // add step
        model.addRandomStep(maxButtons);
        view.updateScore(model.size());
        playSequence();
    }

    private void playSequence() {
        view.lockButtons(true);
        playerBuffer.clear();
        List<Integer> seq = model.getSequence();
        long delayMs = 600;
        long stepDelay = 800;

        for (int i = 0; i < seq.size(); i++) {
            int idx = seq.get(i);
            scheduler.schedule(() -> {
                SwingUtilities.invokeLater(() -> view.flashButton(idx));
            }, delayMs + i * stepDelay, TimeUnit.MILLISECONDS);
        }

        // after playing sequence, allow player input
        scheduler.schedule(() -> {
            playerTurn = true;
            SwingUtilities.invokeLater(() -> view.lockButtons(false));
        }, delayMs + seq.size() * stepDelay, TimeUnit.MILLISECONDS);
    }

    private void onPlayerPress(int index) {
        if (!playerTurn) return;
        view.flashButtonShort(index);
        playerBuffer.add(index);

        boolean ok = model.validatePrefix(playerBuffer);
        if (!ok) {
            playerTurn = false;
            view.lockButtons(true);
            view.showErrorFeedback();
            if (model.isStrictMode()) {
                // strict: reset game
                scheduler.schedule(() -> {
                    SwingUtilities.invokeLater(() -> {
                        model.reset();
                        view.updateScore(0);
                        start();
                    });
                }, 1000, TimeUnit.MILLISECONDS);
            } else {
                // show the same sequence again
                scheduler.schedule(() -> playSequence(), 1000, TimeUnit.MILLISECONDS);
            }
            return;
        }

        // if player completed the full sequence for this round
        if (playerBuffer.size() == model.size()) {
            playerTurn = false;
            view.lockButtons(true);
            view.showSuccessFeedback();
            scheduler.schedule(this::nextRound, 800, TimeUnit.MILLISECONDS);
        }
    }

    public void reset() {
        model.reset();
        playerBuffer.clear();
        playerTurn = false;
        view.updateScore(0);
        view.lockButtons(true);
    }

    public void shutdown() {
        scheduler.shutdownNow();
        uiExecutor.shutdownNow();
    }
}

package org.simon.view;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionListener;
import java.util.function.IntConsumer;

/**
 * Swing UI minimalista: 4 botões coloridos + controles.
 * Patterns: view exposes listeners, não lida com lógica do jogo.
 */
public final class SimonView {
    private final JFrame frame;
    private final JButton[] colorButtons = new JButton[4];
    private final JButton startButton = new JButton("Start");
    private final JButton resetButton = new JButton("Reset");
    private final JLabel scoreLabel = new JLabel("Score: 0");
    private final JCheckBox strictCheck = new JCheckBox("Strict");

    private IntConsumer buttonPressedListener = i -> {};
    private ActionListener startAction = e -> {};
    private ActionListener resetAction = e -> {};
    private java.util.function.Consumer<Boolean> strictListener = b -> {};

    private final Color[] baseColors = {
            new Color(0xFF5555), // red
            new Color(0x55FF55), // green
            new Color(0x5555FF), // blue
            new Color(0xFFFF55)  // yellow
    };

    public SimonView() {
        frame = new JFrame("Simon - Java 21");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setLayout(new BorderLayout(8, 8));

        JPanel board = new JPanel(new GridLayout(2, 2, 6, 6));
        for (int i = 0; i < 4; i++) {
            JButton b = new JButton();
            b.setOpaque(true);
            b.setBorderPainted(false);
            b.setBackground(baseColors[i]);
            final int idx = i;
            b.addActionListener(e -> buttonPressedListener.accept(idx));
            colorButtons[i] = b;
            board.add(b);
        }
        board.setPreferredSize(new Dimension(400, 400));
        frame.add(board, BorderLayout.CENTER);

        JPanel controls = new JPanel();
        controls.add(startButton);
        controls.add(resetButton);
        controls.add(scoreLabel);
        controls.add(strictCheck);
        frame.add(controls, BorderLayout.SOUTH);

        startButton.addActionListener(e -> startAction.actionPerformed(e));
        resetButton.addActionListener(e -> resetAction.actionPerformed(e));
        strictCheck.addActionListener(e -> strictListener.accept(strictCheck.isSelected()));

        frame.pack();
        frame.setLocationRelativeTo(null);
    }

    public void show() {
        SwingUtilities.invokeLater(() -> frame.setVisible(true));
    }

    public void setStartAction(ActionListener act) {
        this.startAction = act;
    }

    public void setResetAction(ActionListener act) {
        this.resetAction = act;
    }

    public void setStrictModeListener(java.util.function.Consumer<Boolean> listener) {
        this.strictListener = listener;
    }

    public void setButtonPressedListener(IntConsumer listener) {
        this.buttonPressedListener = listener;
    }

    public void updateScore(int score) {
        SwingUtilities.invokeLater(() -> scoreLabel.setText("Score: " + score));
    }

    public void lockButtons(boolean locked) {
        SwingUtilities.invokeLater(() -> {
            for (JButton b : colorButtons) {
                b.setEnabled(!locked);
            }
        });
    }

    public void flashButton(int index) {
        JButton b = colorButtons[index];
        Color orig = b.getBackground();
        Color bright = orig.brighter();
        b.setBackground(bright);
        // small delay then restore on EDT
        Timer t = new Timer(400, e -> b.setBackground(orig));
        t.setRepeats(false);
        t.start();
        Toolkit.getDefaultToolkit().beep();
    }

    public void flashButtonShort(int index) {
        JButton b = colorButtons[index];
        Color orig = b.getBackground();
        Color bright = orig.brighter();
        b.setBackground(bright);
        Timer t = new Timer(140, e -> b.setBackground(orig));
        t.setRepeats(false);
        t.start();
        Toolkit.getDefaultToolkit().beep();
    }

    public void showErrorFeedback() {
        // red flash of frame
        SwingUtilities.invokeLater(() -> {
            Color orig = frame.getContentPane().getBackground();
            frame.getContentPane().setBackground(Color.RED);
            Timer t = new Timer(300, e -> frame.getContentPane().setBackground(orig));
            t.setRepeats(false);
            t.start();
            Toolkit.getDefaultToolkit().beep();
        });
    }

    public void showSuccessFeedback() {
        SwingUtilities.invokeLater(() -> {
            Toolkit.getDefaultToolkit().beep();
        });
    }
}

package org.simon.util;

import javax.swing.*;

public final class SwingUtils {
    private SwingUtils() {}

    public static void runOnEDT(Runnable r) {
        if (SwingUtilities.isEventDispatchThread()) r.run();
        else SwingUtilities.invokeLater(r);
    }
}

package org.simon;

import org.simon.controller.SimonController;
import org.simon.model.SimonGame;
import org.simon.view.SimonView;

public class App {
    public static void main(String[] args) {
        SimonGame model = new SimonGame();
        SimonView view = new SimonView();
        SimonController controller = new SimonController(model, view);

        view.show();

        // add shutdown hook to stop schedulers
        Runtime.getRuntime().addShutdownHook(new Thread(controller::shutdown));
    }
}

package org.simon.model;

import org.junit.jupiter.api.Test;

import java.util.List;
import java.util.Random;

import static org.junit.jupiter.api.Assertions.*;

class SimonGameTest {

    @Test
    void addAndValidate() {
        // predictable Random
        SimonGame g = new SimonGame(new Random(0));
        int a = g.addRandomStep(4);
        int b = g.addRandomStep(4);
        List<Integer> seq = g.getSequence();
        assertEquals(2, seq.size());
        assertTrue(g.validatePrefix(List.of(seq.get(0))));
        assertTrue(g.validatePrefix(seq));
        assertFalse(g.validatePrefix(List.of(3,3,3)));
    }
}