import java.util.*;
import java.util.concurrent.locks.*;

public class Monitor{

  private TekstRegister tr;

  private Lock laas = new ReentrantLock();
  //Et "krav". Denne skal sette en traad paa pause hvis TekstRegister er tom.
  private Condition ikkeTom = laas.newCondition();

  //Booleans for aa se om alle tradene av en type er ferdig eller ikke.
  public boolean oversettFerdig = false;
  public boolean settSammenFerdig = false; //Denne brukes forsaavidt ikke.

  public Monitor(TekstRegister t){
    tr = t;
  }

  public void leggTil(String s){
    laas.lock();
    try{
      tr.leggTil(s);
    }
    finally{
      //Vi har lagt noe til, saa vi kan signalisere at det er lov aa fjerne igjen
      System.out.println("Condition ikkeTom signaled");
      ikkeTom.signalAll(); //Dersom denne flyttes under laas.unlock() faar vi feilmelding. Hvorfor?
      laas.unlock();
    }
  }

  //Denne bruker ikke lenger.
  // public String fjern(){
  //   System
  //   laas.lock();
  //   try{
  //     while(lengde() < 1){
  //       System.out.println("Condition ikkeTom locked");
  //       //Dersom lengden er mindre enn 1 maa vi vente paa at noen legger noe til!!
  //       ikkeTom.await();
  //       //Siden vi har denne inne i en while-loekke kan vi kalle paa signal() naarsomhelst og vaere trygge
  //       //paa at vi ikke gaar ut saa lenge lengden er mindre enn 1.
  //       System.out.println("Condition ikkeTom unlocked");
  //     }
  //     return tr.fjern();
  //   }
  //   catch(InterruptedException e){
  //     e.printStackTrace();
  //     return null;
  //   }
  //   finally{
  //     laas.unlock();
  //   }
  // }

  public String[] fjernTo(){
    laas.lock();
    try{
      while(lengde() < 2){
        System.out.println("Condition ikkeTom locked");
        //Dersom lengden er mindre enn 2 maa vi vente paa at noen legger noe til!!
        ikkeTom.await();

        //Hvorfor har vi denne?
        //For hva om en traad kommer inn hit, men det blir ikke lagt til noe mer i tekstRegister?
        if(lengde() < 2 && oversettFerdig){
          return null;
        }
        //Siden vi har denne inne i en while-loekke kan vi kalle paa signal() naarsomhelst og vaere trygge
        //paa at vi ikke gaar ut saa lenge lengden er mindre enn 1.
        System.out.println("Condition ikkeTom unlocked");
      }

      //legg merke til at vi returnerer et array med 2 elementer.
      //Det er flere maater aa returnere to objekter paa.
      //Det var tilfeldig at jeg valgte et array.
      String[] returArray = new String[2];

      //Vi har laasen, sa vi kan fjerne to ganger.
      returArray[0] = tr.fjern();
      returArray[1] = tr.fjern();
      return returArray;
    }
    catch(InterruptedException e){
      e.printStackTrace();
      return null;
    }
    finally{
      laas.unlock();
    }
  }


  public int lengde(){
    laas.lock();
    try{
      return tr.lengde();
    }
    finally{
      laas.unlock();
    }
  }

}