package algs61; // section 6.1
import stdlib.*;
import java.awt.Color;
import algs24.MinPQ;
/* ***********************************************************************
 *  Compilation:  javac CollisionSystem.java
 *  Execution:    java CollisionSystem N               (N random particles)
 *                java CollisionSystem < input.txt     (from a file)
 *
 *  Creates N random particles and simulates their motion according
 *  to the laws of elastic collisions.
 *
 *************************************************************************/

public class CollisionSystem {
  private MinPQ<Event> pq;        // the priority queue
  private double t  = 0.0;        // simulation clock time
  private final double hz = 0.5;        // number of redraw events per clock tick
  private final Particle[] particles;   // the array of particles

  // create a new collision system with the given set of particles
  public CollisionSystem(Particle[] particles) {
    this.particles = particles;
  }

  // updates priority queue with all new events for particle a
  private void predict(Particle a, double limit) {
    if (a == null) return;

    // particle-particle collisions
    for (Particle particle : particles) {
      double dt = a.timeToHit(particle);
      if (t + dt <= limit)
        pq.insert(new Event(t + dt, a, particle));
    }

    // particle-wall collisions
    double dtX = a.timeToHitVerticalWall();
    double dtY = a.timeToHitHorizontalWall();
    if (t + dtX <= limit) pq.insert(new Event(t + dtX, a, null));
    if (t + dtY <= limit) pq.insert(new Event(t + dtY, null, a));
  }

  // redraw all particles
  private void redraw(double limit) {
    StdDraw.clear();
    for (Particle particle : particles) {
      particle.draw();
    }
    StdDraw.show(20);
    if (t < limit) {
      pq.insert(new Event(t + 1.0 / hz, null, null));
    }
  }


  /* ******************************************************************************
   *  Event based simulation for limit seconds
   ********************************************************************************/
  public void simulate(double limit) {

    // initialize PQ with collision events and redraw event
    pq = new MinPQ<>(100000);
    for (Particle particle : particles) {
      predict(particle, limit);
    }
    pq.insert(new Event(0, null, null));        // redraw event


    // the main event-driven simulation loop
    while (!pq.isEmpty()) {

      // get impending event, discard if invalidated
      Event e = pq.delMin();
      if (!e.isValid()) continue;
      Particle a = e.a;
      Particle b = e.b;

      // physical collision, so update positions, and then simulation clock
      for (Particle particle : particles)
        particle.move(e.time - t);
      t = e.time;

      // process event
      if      (a != null && b != null) a.bounceOff(b);              // particle-particle collision
      else if (a != null && b == null) a.bounceOffVerticalWall();   // particle-wall collision
      else if (a == null && b != null) b.bounceOffHorizontalWall(); // particle-wall collision
      else if (a == null && b == null) redraw(limit);               // redraw event

      // update the priority queue with new collisions involving a or b
      predict(a, limit);
      predict(b, limit);
    }
  }


  /* ***********************************************************************
   *  An event during a particle collision simulation. Each event contains
   *  the time at which it will occur (assuming no supervening actions)
   *  and the particles a and b involved.
   *
   *    -  a and b both null:      redraw event
   *    -  a null, b not null:     collision with vertical wall
   *    -  a not null, b null:     collision with horizontal wall
   *    -  a and b both not null:  binary collision between a and b
   *
   *************************************************************************/
  private static class Event implements Comparable<Event> {
    public final double time;         // time that event is scheduled to occur
    public final Particle a, b;       // particles involved in event, possibly null
    public final int countA, countB;  // collision counts at event creation


    // create a new event to occur at time t involving a and b
    public Event(double t, Particle a, Particle b) {
      this.time = t;
      this.a    = a;
      this.b    = b;
      if (a != null) countA = a.count();
      else           countA = -1;
      if (b != null) countB = b.count();
      else           countB = -1;
    }

    // compare times when two events will occur
    public int compareTo(Event that) {
      if      (this.time < that.time) return -1;
      else if (this.time > that.time) return +1;
      else                            return  0;
    }

    // has any collision occurred between when event was created and now?
    public boolean isValid() {
      if (a != null && a.count() != countA) return false;
      if (b != null && b.count() != countB) return false;
      return true;
    }

  }



  /* ******************************************************************************
   *  Sample client
   ********************************************************************************/
  public static void main(String[] args) {
    //args = new String[]{ "20" };
    //StdIn.fromFile ("data/brownian.txt");
    StdIn.fromFile ("data/diffusion.txt");

    // remove the border
    StdDraw.setXscale(1.0/22.0, 21.0/22.0);
    StdDraw.setYscale(1.0/22.0, 21.0/22.0);

    // turn on animation mode
    StdDraw.show(0);

    // the array of particles
    Particle[] particles;

    // create N random particles
    if (args.length == 1) {
      int N = Integer.parseInt(args[0]);
      particles = new Particle[N];
      for (int i = 0; i < N; i++) particles[i] = new Particle();
    }

    // or read from standard input
    else {
      int N = StdIn.readInt();
      particles = new Particle[N];
      for (int i = 0; i < N; i++) {
        double rx     = StdIn.readDouble();
        double ry     = StdIn.readDouble();
        double vx     = StdIn.readDouble();
        double vy     = StdIn.readDouble();
        double radius = StdIn.readDouble();
        double mass   = StdIn.readDouble();
        int r         = StdIn.readInt();
        int g         = StdIn.readInt();
        int b         = StdIn.readInt();
        Color color   = new Color(r, g, b);
        particles[i] = new Particle(rx, ry, vx, vy, radius, mass, color);
      }
    }

    // create collision system and simulate
    CollisionSystem system = new CollisionSystem(particles);
    system.simulate(10000);
  }

}