package myproject.util;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.util.Observable;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
import javax.swing.WindowConstants;

/**
 * A swing implementation of {@link Animator}, using a {@link JFrame}
 * to display the animation.  The {@link JFrame} is created and
 * displayed by the constructor.
 *
 * Calls to <code>update()</code> result in a call to
 * <code>painter.paint()</code>.  This is executed in the swing
 * thread while the main thread is paused for <code>delay</code>
 * milliseconds.
 */
public class SwingAnimator implements Animator {
  // The following fields are manipulated by the main program thread
  private int delay;

  // The following fields are manipulated by the swing thread
  private JFrame frame; // Swing representation of an OS window
  private ContentPane content; // A paintable component
  private boolean disposed = false; // If true, then die

  /**
   * Creates and displays a {@link JFrame} for the animation.
   * @param name  The name to be displayed on the graphical window.
   * @param width The width of the display, in pixels.
   * @param height The height of the display, in pixels.
   * @param delay Time to pause after an update, in milliseconds.
   */
  public SwingAnimator(final SwingAnimatorPainter painter, final String name, final int width, final int height, int delay) {
    this.delay = delay;
    // Create a graphics window and display it
    SwingUtilities.invokeLater(() -> {
      content = new ContentPane(painter, width, height); // A paintable component for content
      frame = new JFrame();  // An OS window
      frame.setTitle(name);  // The title of the Frame
      frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);  // End program if Frame is closed
      frame.setContentPane(content); // Associate the content with the Frame
      frame.pack(); // Fix the layout of the Frame
      frame.setVisible(true); // Display the Frame
    });
  }

  /**
   * Throw away this visualization.
   */
  public void dispose() {
    SwingUtilities.invokeLater(() -> {
      frame.dispose();
      disposed = true;
    });
  }

  /**
   * Calls to <code>update</code> are executed in the swing thread,
   * while the main thread is paused for <code>delay</code>
   * milliseconds.
   */
  public void update(final Observable model, Object ignored) {
    if (disposed)
      throw new IllegalStateException();

    // Redraw the window
    //   content.repaint() causes a call to content.paint(g)
    //   where g is an appropriate graphics argument.
    SwingUtilities.invokeLater(() -> content.repaint());

    // Delay the main thread
    try {
      Thread.sleep(delay);
    } catch (InterruptedException e) {}
  }

  /**
   * A component for painting.
   * All code is executed in the swing thread.
   */
  private static class ContentPane extends JPanel {
    private static final long serialVersionUID = 2008L;
    private int width;
    private int height;
    private SwingAnimatorPainter painter;

    ContentPane(SwingAnimatorPainter painter, int width, int height) {
      this.painter = painter;
      this.width = width;
      this.height = height;
      setPreferredSize(new Dimension(width, height));
      setDoubleBuffered(true);
      setOpaque(true);
      setBackground(Color.WHITE);
    }

    public void paint(Graphics g) {
      // This test is necessary because the swing thread may call this
      // method before the simulation calls SwingAnimator.update()
      if (painter != null ) {
        // The clearRect is necessary, since JPanel is lightweight
        g.clearRect(0, 0, width, height);
        painter.paint(g);
      }
    }
  }
}