import java.awt.*;
import java.awt.event.*;
import java.awt.geom.Point2D;
import java.util.ArrayList;
import java.util.Random;

import javax.swing.*;


public class RobuttonMain
{
    public static void main(String[] args)
    {
//        double alpha = Math.toDegrees(Math.atan2(74.48225726895468-63.841134965679906, 82.03132543476201-98.03974349211745));
//        if (alpha < 0) alpha+=360;
//        System.out.println(alpha);// (180 * value / Math.PI);

        JFrame frame = new JFrame("RobuttonMain");
        frame.setBackground(Color.lightGray);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        RobuttonPanel panel = new RobuttonPanel();
        frame.add(panel);

        frame.pack();
        frame.setVisible(true);

        panel.start();
    }
}



class RobuttonPanel extends JPanel
{
    int xSize = 200;
    int ySize = 200;
    ArrayList <Robutton> roblist= new ArrayList<Robutton>();
    ArrayList <Coin> coinlist= new ArrayList<Coin>();


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

        g.setColor(Color.BLACK);
        for (Robutton rob : roblist) {
            g.fillOval(rob.getXInt()-Robutton.radius, rob.getYInt()-Robutton.radius, Robutton.radius*2, Robutton.radius*2);
//            g.setColor(Color.RED);
//            g.drawString(Integer.toString(i), roblist.get(i).getXInt()-2, roblist.get(i).getYInt()+4);
        }
        for (Coin coin : coinlist) {
            g.setColor(Color.GREEN);
            g.fillOval(coin.getXInt()-Coin.radius, coin.getYInt()-Coin.radius, Coin.radius*2, Coin.radius*2);
        }
    }



    public void start()
    {
        for (int i = 0; i < 15; i++) {
            Robutton rob = new Robutton (getRandomFreePos(Robutton.radius));
            rob.setDirectionDegree(new Random().nextInt(360));
            roblist.add(rob);
        }

        for (int i = 0; i < 5; i++) {
            coinlist.add(new Coin (getRandomFreePos(Coin.radius)));
        }


//        Robutton rob = new Robutton (new Point2D.Double(170, 45));
//        rob.setDirectionDegree(0);
//        roblist.add(rob);
//        rob = new Robutton (new Point2D.Double(140, 45));
//        rob.setDirectionDegree(180);
//        roblist.add(rob);

        Thread mainThread = new Thread() {
            @Override
            public void run()
            {
                ActionListener taskPerformer = new ActionListener() {
                    public void actionPerformed(ActionEvent e){
                        doOneStep();
                    }
                };
                Timer timer = new Timer(6, taskPerformer);
                timer.start();
            }
        };
        mainThread.start();
    }



    public void doOneStep() {
        if (true) {
            for (Robutton rob : roblist)
                rob.moveSimple();


            for (Robutton rob : roblist)
                rob.collideBoundSimple(xSize, ySize);

            for (int i = 0; i < roblist.size()-1; i++) {
                for (int j = i+1; j < roblist.size(); j++) {
                    roblist.get(i).collideRobuttonSimple(roblist.get(j));
                }
            }

            for (Robutton rob : roblist) {
                for (Coin coin : coinlist) {
                    rob.collideCoinSimple(coin);
                }
            }
            repaint();
            return;
        }

        double timeLeft = 1.0;

        while (timeLeft > 0) {
            double firstCollision = timeLeft;
            for (Robutton rob : roblist) {
                double collisionTime = rob.collideBound(xSize, ySize, firstCollision);
                if (collisionTime < firstCollision)
                    firstCollision = collisionTime;
            }

            for (int i = 0; i < roblist.size()-1; i++) {
                for (int j = i+1; j < roblist.size(); j++) {
                    double collisionTime = roblist.get(i).collideRobutton(roblist.get(j), firstCollision);
                    if (collisionTime < firstCollision)
                        firstCollision = collisionTime;
                }
            }

            for (Robutton rob : roblist) {
                for (Coin coin : coinlist) {
                    double collisionTime = rob.collideCoin(coin, firstCollision);
                    if (collisionTime < firstCollision)
                        firstCollision = collisionTime;
                }
            }


            System.out.println("Started moving, time: " + firstCollision);
            for (Robutton rob : roblist)
                rob.move(firstCollision);
            repaint();
            timeLeft -= firstCollision;
        }
    }



    private Point2D.Double getRandomFreePos(int radius) {
        Random random = new Random();
        boolean collide = false;
        Point2D.Double nextPos;
        do {
            collide = false;
            nextPos = new Point2D.Double( random.nextInt(xSize-2-radius*2)+radius+1, random.nextInt(ySize-radius*2)+radius+1);
            for (Robutton rob : roblist){
                if ((nextPos.distance(rob.getPos()) < Robutton.radius*2+1)) {
                    collide = true;
                }
            }
            for (Coin coin : coinlist){
                if ((nextPos.distance(coin.pos) < Coin.radius*2+1)) {
                    collide = true;
                }
            }
        }while (collide == true);
        return nextPos;
    }



    @Override
    public Dimension getPreferredSize() {
        return new Dimension (xSize, ySize);

    }
}