// threads/CarBuilder.java
// (c)2016 MindView LLC: see Copyright.txt
// We make no guarantees that this code is fit for any purpose.
// Visit http://mindviewinc.com/Books/OnJava/ for more book information.
// A complex example of tasks working together
import java.util.concurrent.*;
import java.util.*;

class Car {
  private final int id;
  private boolean
    engine = false, driveTrain = false, wheels = false;
  public Car(int idn)  { id = idn; }
  // Empty Car object:
  public Car()  { id = -1; }
  public synchronized int getId() { return id; }
  public synchronized void addEngine() { engine = true; }
  public synchronized void addDriveTrain() {
    driveTrain = true;
  }
  public synchronized void addWheels() { wheels = true; }
  public synchronized String toString() {
    return "Car " + id + " [" + " engine: " + engine
      + " driveTrain: " + driveTrain
      + " wheels: " + wheels + " ]";
  }
}

class CarQueue extends LinkedBlockingQueue<Car> {}

class ChassisBuilder implements Runnable {
  private CarQueue carQueue;
  private int counter = 0;
  public ChassisBuilder(CarQueue cq) { carQueue = cq; }
  @Override
  public void run() {
    try {
      while(!Thread.interrupted()) {
        TimeUnit.MILLISECONDS.sleep(500);
        // Make chassis:
        Car c = new Car(counter++);
        System.out.println("ChassisBuilder created " + c);
        // Insert into queue
        carQueue.put(c);
      }
    } catch(InterruptedException e) {
      System.out.println("Interrupted: ChassisBuilder");
    }
    System.out.println("ChassisBuilder off");
  }
}

class Assembler implements Runnable {
  private CarQueue chassisQueue, finishingQueue;
  private Car car;
  private CyclicBarrier barrier = new CyclicBarrier(4);
  private RobotPool robotPool;
  public
  Assembler(CarQueue cq, CarQueue fq, RobotPool rp) {
    chassisQueue = cq;
    finishingQueue = fq;
    robotPool = rp;
  }
  public Car car() { return car; }
  public CyclicBarrier barrier() { return barrier; }
  @Override
  public void run() {
    try {
      while(!Thread.interrupted()) {
        // Blocks until chassis is available:
        car = chassisQueue.take();
        // Hire robots to perform work:
        robotPool.hire(EngineRobot.class, this);
        robotPool.hire(DriveTrainRobot.class, this);
        robotPool.hire(WheelRobot.class, this);
        barrier.await(); // Until the robots finish
        // Put car into finishingQueue for further work
        finishingQueue.put(car);
      }
    } catch(InterruptedException e) {
      System.out.println(
        "Exiting Assembler via interrupt");
    } catch(BrokenBarrierException e) {
      // This one we want to know about
      throw new RuntimeException(e);
    }
    System.out.println("Assembler off");
  }
}

class Reporter implements Runnable {
  private CarQueue carQueue;
  public Reporter(CarQueue cq) { carQueue = cq; }
  @Override
  public void run() {
    try {
      while(!Thread.interrupted()) {
        System.out.println(carQueue.take());
      }
    } catch(InterruptedException e) {
      System.out.println(
        "Exiting Reporter via interrupt");
    }
    System.out.println("Reporter off");
  }
}

abstract class Robot implements Runnable {
  private RobotPool pool;
  public Robot(RobotPool p) { pool = p; }
  protected Assembler assembler;
  public Robot assignAssembler(Assembler assembler) {
    this.assembler = assembler;
    return this;
  }
  private boolean engage = false;
  public synchronized void engage() {
    engage = true;
    notifyAll();
  }
  // The part of run() that's different for each robot:
  abstract protected void performService();
  public void run() {
    try {
      powerDown(); // Wait until needed
      while(!Thread.interrupted()) {
        performService();
        assembler.barrier().await(); // Synchronize
        // We're done with that job...
        powerDown();
      }
    } catch(InterruptedException e) {
      System.out.println(
        "Exiting " + this + " via interrupt");
    } catch(BrokenBarrierException e) {
      // This one we want to know about
      throw new RuntimeException(e);
    }
    System.out.println(this + " off");
  }
  private synchronized void
  powerDown() throws InterruptedException {
    engage = false;
    assembler = null; // Disconnect from the Assembler
    // Put ourselves back in the available pool:
    pool.release(this);
    while(engage == false)  // Power down
      wait();
  }
  public String toString() {
    return getClass().getName();
  }
}

class EngineRobot extends Robot {
  public EngineRobot(RobotPool pool) { super(pool); }
  protected void performService() {
    System.out.println(this + " installing engine");
    assembler.car().addEngine();
  }
}

class DriveTrainRobot extends Robot {
  public DriveTrainRobot(RobotPool pool) { super(pool); }
  protected void performService() {
    System.out.println(this + " installing DriveTrain");
    assembler.car().addDriveTrain();
  }
}

class WheelRobot extends Robot {
  public WheelRobot(RobotPool pool) { super(pool); }
  protected void performService() {
    System.out.println(this + " installing Wheels");
    assembler.car().addWheels();
  }
}

class RobotPool {
  // Quietly prevents identical entries:
  private Set<Robot> pool = new HashSet<>();
  public synchronized void add(Robot r) {
    pool.add(r);
    notifyAll();
  }
  public synchronized void
  hire(Class<? extends Robot> robotType, Assembler d)
  throws InterruptedException {
    for(Robot r : pool)
      if(r.getClass().equals(robotType)) {
        pool.remove(r);
        r.assignAssembler(d);
        r.engage(); // Power it up to do the task
        return;
      }
    wait(); // None available
    hire(robotType, d); // Try again, recursively
  }
  public synchronized void release(Robot r) { add(r); }
}

public class CarBuilder {
  public static void
  main(String[] args) throws Exception {
    CarQueue chassisQueue = new CarQueue(),
             finishingQueue = new CarQueue();
    ExecutorService es = Executors.newCachedThreadPool();
    RobotPool robotPool = new RobotPool();
    es.execute(new EngineRobot(robotPool));
    es.execute(new DriveTrainRobot(robotPool));
    es.execute(new WheelRobot(robotPool));
    es.execute(new Assembler(
      chassisQueue, finishingQueue, robotPool));
    es.execute(new Reporter(finishingQueue));
    // Start everything running by producing chassis:
    es.execute(new ChassisBuilder(chassisQueue));
    TimeUnit.SECONDS.sleep(7);
    es.shutdownNow();
  }
}
/* Output:
ChassisBuilder created Car 0 [ engine: false driveTrain:
false wheels: false ]
WheelRobot installing Wheels
DriveTrainRobot installing DriveTrain
EngineRobot installing engine
Car 0 [ engine: true driveTrain: true wheels: true ]
ChassisBuilder created Car 1 [ engine: false driveTrain:
false wheels: false ]
EngineRobot installing engine
WheelRobot installing Wheels
DriveTrainRobot installing DriveTrain
Car 1 [ engine: true driveTrain: true wheels: true ]
ChassisBuilder created Car 2 [ engine: false driveTrain:
false wheels: false ]
DriveTrainRobot installing DriveTrain
WheelRobot installing Wheels
EngineRobot installing engine
Car 2 [ engine: true driveTrain: true wheels: true ]
ChassisBuilder created Car 3 [ engine: false driveTrain:
false wheels: false ]
DriveTrainRobot installing DriveTrain
WheelRobot installing Wheels
EngineRobot installing engine
Car 3 [ engine: true driveTrain: true wheels: true ]
ChassisBuilder created Car 4 [ engine: false driveTrain:
false wheels: false ]
EngineRobot installing engine
DriveTrainRobot installing DriveTrain
WheelRobot installing Wheels
Car 4 [ engine: true driveTrain: true wheels: true ]
ChassisBuilder created Car 5 [ engine: false driveTrain:
false wheels: false ]
EngineRobot installing engine
WheelRobot installing Wheels
DriveTrainRobot installing DriveTrain
Car 5 [ engine: true driveTrain: true wheels: true ]
ChassisBuilder created Car 6 [ engine: false driveTrain:
false wheels: false ]
EngineRobot installing engine
WheelRobot installing Wheels
DriveTrainRobot installing DriveTrain
Car 6 [ engine: true driveTrain: true wheels: true ]
ChassisBuilder created Car 7 [ engine: false driveTrain:
false wheels: false ]
EngineRobot installing engine
WheelRobot installing Wheels
DriveTrainRobot installing DriveTrain
Car 7 [ engine: true driveTrain: true wheels: true ]
ChassisBuilder created Car 8 [ engine: false driveTrain:
false wheels: false ]
EngineRobot installing engine
WheelRobot installing Wheels
DriveTrainRobot installing DriveTrain
Car 8 [ engine: true driveTrain: true wheels: true ]
ChassisBuilder created Car 9 [ engine: false driveTrain:
false wheels: false ]
DriveTrainRobot installing DriveTrain
EngineRobot installing engine
WheelRobot installing Wheels
Car 9 [ engine: true driveTrain: true wheels: true ]
ChassisBuilder created Car 10 [ engine: false driveTrain:
false wheels: false ]
DriveTrainRobot installing DriveTrain
EngineRobot installing engine
WheelRobot installing Wheels
Car 10 [ engine: true driveTrain: true wheels: true ]
ChassisBuilder created Car 11 [ engine: false driveTrain:
false wheels: false ]
EngineRobot installing engine
WheelRobot installing Wheels
DriveTrainRobot installing DriveTrain
Car 11 [ engine: true driveTrain: true wheels: true ]
ChassisBuilder created Car 12 [ engine: false driveTrain:
false wheels: false ]
DriveTrainRobot installing DriveTrain
WheelRobot installing Wheels
EngineRobot installing engine
Car 12 [ engine: true driveTrain: true wheels: true ]
Exiting Assembler via interrupt
Exiting EngineRobot via interrupt
Exiting WheelRobot via interrupt
Exiting DriveTrainRobot via interrupt
DriveTrainRobot off
Exiting Reporter via interrupt
Interrupted: ChassisBuilder
Reporter off
WheelRobot off
EngineRobot off
Assembler off
ChassisBuilder off
*/