package algs61; // section 6.1
import stdlib.*;
import java.awt.Color;
/* ***********************************************************************
 *  Compilation:  javac Particle.java
 *
 *  A particle moving in the unit box with a given position, velocity,
 *  radius, and mass.
 *
 *************************************************************************/

public class Particle {
	private static final double INFINITY = Double.POSITIVE_INFINITY;

	private double rx, ry;    // position
	private double vx, vy;    // velocity
	private final double radius;    // radius
	private final double mass;      // mass
	private final Color color;      // color
	private int count;        // number of collisions so far


	// create a new particle with given parameters
	public Particle(double rx, double ry, double vx, double vy, double radius, double mass, Color color) {
		this.vx = vx;
		this.vy = vy;
		this.rx = rx;
		this.ry = ry;
		this.radius = radius;
		this.mass   = mass;
		this.color  = color;
	}

	// create a random particle in the unit box (overlaps not checked)
	public Particle() {
		rx     = Math.random();
		ry     = Math.random();
		vx     = 0.01 * (Math.random() - 0.5);
		vy     = 0.01 * (Math.random() - 0.5);
		radius = 0.01;
		mass   = 0.5;
		//color  = Color.BLACK;
		color  = new Color (StdRandom.uniform(200), StdRandom.uniform(200), StdRandom.uniform(200));
	}

	// updates position
	public void move(double dt) {
		rx += vx * dt;
		ry += vy * dt;
	}

	// draw the particle
	public void draw() {
		StdDraw.setPenColor(color);
		StdDraw.filledCircle(rx, ry, radius);
	}

	// return the number of collisions involving this particle
	public int count() { return count; }


	// how long into future until collision between this particle a and b?
	public double timeToHit(Particle b) {
		Particle a = this;
		if (a == b) return INFINITY;
		double dx  = b.rx - a.rx;
		double dy  = b.ry - a.ry;
		double dvx = b.vx - a.vx;
		double dvy = b.vy - a.vy;
		double dvdr = dx*dvx + dy*dvy;
		if (dvdr > 0) return INFINITY;
		double dvdv = dvx*dvx + dvy*dvy;
		double drdr = dx*dx + dy*dy;
		double sigma = a.radius + b.radius;
		double d = (dvdr*dvdr) - dvdv * (drdr - sigma*sigma);
		// if (drdr < sigma*sigma) StdOut.println("overlapping particles");
		if (d < 0) return INFINITY;
		return -(dvdr + Math.sqrt(d)) / dvdv;
	}

	// how long into future until this particle collides with a vertical wall?
	public double timeToHitVerticalWall() {
		if      (vx > 0) return (1.0 - rx - radius) / vx;
		else if (vx < 0) return (radius - rx) / vx;
		else             return INFINITY;
	}

	// how long into future until this particle collides with a horizontal wall?
	public double timeToHitHorizontalWall() {
		if      (vy > 0) return (1.0 - ry - radius) / vy;
		else if (vy < 0) return (radius - ry) / vy;
		else             return INFINITY;
	}

	// update velocities upon collision between this particle and that particle
	public void bounceOff(Particle that) {
		double dx  = that.rx - this.rx;
		double dy  = that.ry - this.ry;
		double dvx = that.vx - this.vx;
		double dvy = that.vy - this.vy;
		double dvdr = dx*dvx + dy*dvy;             // dv dot dr
		double dist = this.radius + that.radius;   // distance between particle centers at collison

		// normal force F, and in x and y directions
		double F = 2 * this.mass * that.mass * dvdr / ((this.mass + that.mass) * dist);
		double fx = F * dx / dist;
		double fy = F * dy / dist;

		// update velocities according to normal force
		this.vx += fx / this.mass;
		this.vy += fy / this.mass;
		that.vx -= fx / that.mass;
		that.vy -= fy / that.mass;

		// update collision counts
		this.count++;
		that.count++;
	}

	// update velocity of this particle upon collision with a vertical wall
	public void bounceOffVerticalWall() {
		vx = -vx;
		count++;
	}

	// update velocity of this particle upon collision with a horizontal wall
	public void bounceOffHorizontalWall() {
		vy = -vy;
		count++;
	}

	// return kinetic energy associated with this particle
	public double kineticEnergy() { return 0.5 * mass * (vx*vx + vy*vy); }
}