import javax.swing.*;
import java.awt.*;
import java.util.Stack;

/**
 * Hauptklasse zum Starten der Türme von Hanoi mit grafischer Darstellung.
 */
public class HanoiVisualizer {

    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> {
            HanoiFrame frame = new HanoiFrame(4); // 4 Scheiben
            frame.setVisible(true);
        });
    }
}

/**
 * JFrame zur Darstellung der Türme und Animation der Bewegungen.
 */
class HanoiFrame extends JFrame {

    private final HanoiPanel panel;

    /**
     * Konstruktor für das Hauptfenster.
     *
     * @param numDisks Anzahl der Scheiben
     */
    public HanoiFrame(int numDisks) {
        setTitle("Türme von Hanoi - Visualisierung");
        setSize(800, 400);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLocationRelativeTo(null);

        panel = new HanoiPanel(numDisks);
        add(panel);
        new Thread(panel::solve).start();
    }
}

/**
 * JPanel, das die drei Türme und die Scheiben zeichnet.
 */
class HanoiPanel extends JPanel {

    private final Stack<Integer>[] towers;
    private final int numDisks;

    /**
     * Konstruktor für das Zeichenpanel.
     *
     * @param numDisks Anzahl der Scheiben
     */
    public HanoiPanel(int numDisks) {
        this.numDisks = numDisks;
        towers = new Stack[3];
        for (int i = 0; i < 3; i++) {
            towers[i] = new Stack<>();
        }
        for (int i = numDisks; i >= 1; i--) {
            towers[0].push(i);
        }
    }

    /**
     * Startet den rekursiven Hanoi-Algorithmus.
     */
    public void solve() {
        try {
            hanoi(numDisks, 0, 2, 1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * Führt den rekursiven Hanoi-Algorithmus mit 3 Türmen aus.
     *
     * @param n     Anzahl der Scheiben
     * @param from  Quell-Turm
     * @param to    Ziel-Turm
     * @param aux   Hilfs-Turm
     */
    private void hanoi(int n, int from, int to, int aux) throws InterruptedException {
        if (n == 1) {
            moveDisk(from, to);
        } else {
            hanoi(n - 1, from, aux, to);
            moveDisk(from, to);
            hanoi(n - 1, aux, to, from);
        }
    }

    /**
     * Bewegt eine Scheibe von einem Turm zum anderen.
     *
     * @param from Quell-Turm
     * @param to   Ziel-Turm
     */
    private void moveDisk(int from, int to) throws InterruptedException {
        int disk = towers[from].pop();
        towers[to].push(disk);
        repaint();
        Thread.sleep(500); // Wartezeit für Animation
    }

    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        drawTowers(g);
    }

    /**
     * Zeichnet die drei Türme und alle Scheiben.
     *
     * @param g Grafik-Kontext
     */
    private void drawTowers(Graphics g) {
        int width = getWidth();
        int height = getHeight();

        int towerWidth = 20;
        int towerHeight = 200;

        int baseY = height - 50;
        int[] xPositions = {width / 4, width / 2, 3 * width / 4};

        // Türme zeichnen
        g.setColor(Color.DARK_GRAY);
        for (int x : xPositions) {
            g.fillRect(x - towerWidth / 2, baseY - towerHeight, towerWidth, towerHeight);
        }

        // Scheiben zeichnen
        for (int i = 0; i < 3; i++) {
            Stack<Integer> tower = towers[i];
            for (int j = 0; j < tower.size(); j++) {
                int disk = tower.get(j);
                int diskWidth = 30 + disk * 20;
                int diskHeight = 20;
                int x = xPositions[i] - diskWidth / 2;
                int y = baseY - (j + 1) * diskHeight;

                g.setColor(new Color(50 + disk * 40, 100, 200));
                g.fillRoundRect(x, y, diskWidth, diskHeight, 10, 10);
                g.setColor(Color.BLACK);
                g.drawRoundRect(x, y, diskWidth, diskHeight, 10, 10);
            }
        }
    }
}