package be.ac.vub.ir.multithreading;

/**
 * Another version, with consumers that are also producers
 */
import java.util.Random;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class ApplesOrangesWithDeadlock {
	static final int MAX_SLEEP_TIME = 100; 
	static int NBR_APPLE_PRODUCERS = 2, NBR_ORANGE_PRODUCERS=2;
	private int nbrApples=5, nbrOranges=5, consumedApples=0, consumedOranges=0;
	boolean stop=false;
	
	private final ReentrantLock lock = new ReentrantLock();
	private final Condition noApples  = lock.newCondition(); 
	private final Condition noOranges = lock.newCondition(); 

	/****  PROGRAM  ***/
	public static void main(String[] args) {
		new ApplesOrangesWithDeadlock();
	}
	
	ApplesOrangesWithDeadlock(){
		start();
	}
	public void start(){
		System.out.println("     nbrApples     nbrOranges     consumedApples   consumedOranges");
		for(int i=0;i<NBR_APPLE_PRODUCERS;i++){
			Thread t = new Thread(){
				public void run(){
					while(!stop){
						int t = randomPeriod();
						try {
							sleep(t);
							consume(true);
						} catch (InterruptedException e) { e.printStackTrace(); }
						t = randomPeriod();
						try {
							sleep(t);
						} catch (InterruptedException e) { e.printStackTrace(); }
						addApples(2);
					}
				}
			};
			t.start();
		}
		for(int i=0;i<NBR_ORANGE_PRODUCERS;i++){
			Thread t = new Thread(){
				public void run(){
					while(!stop){
						int t = randomPeriod();
						try {
							sleep(t);
							consume(false);
						} catch (InterruptedException e) { e.printStackTrace(); }
						t = randomPeriod();
						try {
							sleep(t);
						} catch (InterruptedException e) { e.printStackTrace(); }
						addOranges(2);
					}
				}
			};
			t.start();
		}
	}
	public void addApples(int nbr){
		lock.lock();
		nbrApples+=nbr;
		printSituation();
		noApples.signalAll();
		lock.unlock();
	}
	public void addOranges(int nbr){
		lock.lock();
		nbrOranges+=nbr;
		printSituation();
		noOranges.signalAll();
		lock.unlock();	
	}
	volatile int nbrWaitingThreads=0;
	public void consume(boolean appleProducer) throws InterruptedException{
		lock.lock();
		boolean allConditionsPassed;
		do{
			allConditionsPassed=true;
			
			if (nbrApples == 0){
				nbrWaitingThreads++;
				System.out.println("Thread "+(appleProducer?"A":"O")+" waiting for apples. Nbr apples = "+nbrApples+" waiting threads: "+nbrWaitingThreads);
				noApples.await();
				nbrWaitingThreads--;
				System.out.println(" ** Thread "+(appleProducer?"A":"O")+" waiting for apples released. Waiting threads: "+nbrWaitingThreads);
				allConditionsPassed=false;
			}
			if (nbrOranges == 0){
				nbrWaitingThreads++;
				System.out.println("Thread "+(appleProducer?"A":"O")+" waiting for oranges. Nbr oranges = "+nbrOranges+" waiting threads: "+nbrWaitingThreads);
				noOranges.await();
				nbrWaitingThreads--;
				System.out.println(" ** Thread "+(appleProducer?"A":"O")+" waiting for oranges released. Waiting threads: "+nbrWaitingThreads);
				allConditionsPassed=false;
			}
		}while(!allConditionsPassed); // if one condition failed, thread has to go through all checks again
		nbrApples--;
		consumedApples++;
		nbrOranges--;
		consumedOranges++;
		printSituation();
		lock.unlock();
	}
	public void printSituation(){
		System.out.println("\t"+nbrApples+"\t\t"+nbrOranges+"\t\t"+consumedApples+"\t\t"+consumedOranges);
	}
	Random r = new Random();
	private synchronized int randomPeriod(){
		return r.nextInt(MAX_SLEEP_TIME);
	}
}