import java.util.ArrayList;
import java.util.Random;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class TestKokker {
    

    public static void main(String[] args) {
        
        final int ANT_TRAADER = 10;

        CountDownLatch barriere = new CountDownLatch(ANT_TRAADER);
        Monitor monitor = new Monitor();

        Runnable kokkOppgave = new Kokk(monitor, barriere);
        Runnable servitoerOppgave = new Servitoer(monitor, barriere);

        ArrayList<Thread> traader = new ArrayList<>();


        for (int i = 0; i < ANT_TRAADER/2; i++) {
            traader.add(new Thread(kokkOppgave));
            traader.add(new Thread(servitoerOppgave));
        }

        for (Thread thread : traader) {
            thread.start();
        }

        // for (Thread thread : traader) {
        //     try {
        //         thread.join();
        //     } catch (InterruptedException e) {
        //         System.err.println(e);
        //     }
        // }
        try {
            barriere.await();
        } catch (InterruptedException e) {
            System.out.println(e);
        }

        System.out.println("Traadene ferdige.");


        
    }
}

class Monitor {

    ArrayList<String> bor = new ArrayList<>();
    Lock laas = new ReentrantLock();
    Condition ikkeTom = laas.newCondition();

    public void leggTilRett(String rett) {
        laas.lock();
        try {
            bor.add(rett);
            ikkeTom.signalAll();
        }
        finally {
            laas.unlock();
        }
    }

    public String taAvTallerken() {
        laas.lock();
        try {
            while (bor.isEmpty()) {
                try {
                    ikkeTom.await();
                } catch (InterruptedException e) {
                    System.err.println(e);
                }
                
            }
            return bor.remove(0);
            
        }
        finally {
            laas.unlock();
        }
    }

}

class Kokk implements Runnable {
    private Monitor monitor;
    private CountDownLatch barriere;

    Kokk(Monitor m, CountDownLatch b) {
        monitor = m;
        barriere = b;
    }

    @Override
    public void run() {

        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                System.err.println(e);
            }
            monitor.leggTilRett("Rett");
        }
        barriere.countDown();
    }
}

class Servitoer implements Runnable {

    private Monitor monitor;
    private CountDownLatch barriere;

    Servitoer(Monitor m, CountDownLatch b) {
        monitor = m;
        barriere = b;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            String rett = monitor.taAvTallerken();
            try {
                Thread.sleep(new Random().nextInt(1000));
            } catch (InterruptedException e) {
                System.err.println(e);
            }
            System.out.println("Rett servert");
        }
        barriere.countDown();
    }
}