import java.awt.*;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Random;
import javax.swing.*;

public class Chp30Lab2st {
    static int     speedOffset     = 5;
    static int     speedRandomness = 7;
    static boolean randomColors    = false;

    static int x  = 800;
    static int y  = 600;
    static int cx = x + 16;
    static int cy = y + 39;

    public static void main(String args[]) {
        int circleCount = 50;
        int circleSize = 30;
        try {
            circleCount = Integer.parseInt(JOptionPane.showInputDialog("How many circles?"));
        } catch (NumberFormatException ignored) {
        }
        try {
            circleSize = Integer.parseInt(JOptionPane.showInputDialog("What is the diameter of your circles? "));
        } catch (NumberFormatException ignored) {
        }



        GfxApp gfx = new GfxApp(circleCount, circleSize);
        gfx.setBounds(0, 0, cx, cy);
        gfx.setResizable(false);
        gfx.setVisible(true);
    }
}
class GfxApp extends Frame {
    private static final int    timeDelay = 10;
    private final        int    incX      = 5;
    private final        int    incY      = 5;
    private final        int    circleCount;
    private final        int    diameter;
    private final Random r  = new Random();
    private int x=255;
    private int y=255;
    private int z=255;

    GfxApp(int count, int size) {
        circleCount = count;
        diameter = size;
    }

    GfxApp() {
        this(50, 30);
    }

    public void paint(Graphics g) {
        Coordinate currentCoord = new Coordinate(this, incX, incY, diameter);
        Queue<Circle> circles = new LinkedList<>();
        circles.add(new Circle(diameter, currentCoord, getColor()));
        for (int k = 0; k < 2000; k++) {
            currentCoord.moveCircle();
            currentCoord.hitEdge();
            circles.add(new Circle(diameter, new Coordinate(currentCoord), getColor()));
            if (circles.size() > circleCount)
                circles.remove().eraseCircle(g);
            for (Circle c : circles) {
                c.drawCircle(g);
            }
            delay();
        }
    }

    private void delay() {
        try {
            Thread.sleep(timeDelay);
        } catch (InterruptedException ignored) {
        }
    }

    private Color getColor() {
        x-=5;
        if(x<=10)
            x=255;
        y-=10;
        if(y<=10)
            y=255;
        z-=20;
        if(z<=10)
            z=255;
        return  new Color (256-x,256-y,256-z);
    }
}
class Coordinate {
    private final GfxApp  gfx;
    private       int     x;
    private       int     y;
    private       int     velX;         // increment movement of X coordinate
    private       int     velY;         // increment movement of Y coordinate
    private       boolean xDir = true;  // flag to determine add/subtract of increment for X
    private       boolean yDir = false; // flag to determine add/subtract of increment for Y
    private       int     radius;

    Coordinate(Coordinate copy) {
        gfx = copy.gfx;
        x = copy.x;
        y = copy.y;
        velX = copy.velX;
        velY = copy.velY;
        xDir = copy.xDir;
        yDir = copy.yDir;
        radius = copy.radius;
    }

    Coordinate(GfxApp ga, int vx, int vy, int d) {
        gfx = ga;
        this.x = ga.getBounds().width / 2;
        this.y = ga.getBounds().height / 2;
        velX = vx;
        velY = vy;
        radius = d / 2;
    }

    void moveCircle() {
        x += xDir ? velX : -velX;
        y += yDir ? velY : -velY;
    }

    private void newData() {
        Random random = new Random();
        velX = random.nextInt(Chp30Lab2st.speedRandomness) + Chp30Lab2st.speedOffset;
        velY = random.nextInt(Chp30Lab2st.speedRandomness) + Chp30Lab2st.speedOffset;
    }

    void hitEdge() {
        xDir = outOfRangeX() ? x < gfx.getBounds().width / 2 : xDir;
        yDir = outOfRangeY() ? y < gfx.getBounds().height / 2 : yDir;
        if (outOfRangeX() || outOfRangeY())
            newData();
    }

    private boolean outOfRangeX() {
        return x < radius || x > gfx.getBounds().width - radius;
    }

    private boolean outOfRangeY() {
        return y < radius + 30 || y > gfx.getBounds().height - radius;
    }

    int x() {
        return x;
    }

    int y() {
        return y;
    }
}





class Circle {
    private int diameter;
    private int radius;
    private Coordinate xy;
    private Color color;

    Circle(int s, Coordinate coord, Color c) {
        diameter = s;
        radius = s / 2;
        xy = coord;
        color = c;
    }

    void drawCircle(Graphics g) {
        g.setColor(color);
        g.drawOval(xy.x() - radius, xy.y() - radius, diameter, diameter);
    }

    void eraseCircle(Graphics g) {
        g.setColor(Color.white);
        g.drawOval(xy.x() - radius, xy.y() - radius, diameter, diameter);
    }
}