// Oppgave  2a  

abstract class Aktivitet implements Comparable<Aktivitet>  {	
    int tid;

    // OK om det ikke er noen konstruktor og at starttid alltid er null
    Aktivitet(int startTid) {  
         if (startTid >= 0) tid = startTid;
         else throw new RuntimeException(" Starttid kan ikke vaere negativ");
    }

    Aktivitet neste = null;   
    Aktivitet forrige = null;

    public int compareTo(Aktivitet a) {
        return (this.tid - a.tid);
    }
    
    // Bare simulatoren skal kalle denne metoden
    abstract void handling();
}

// Oppgave 2b

class PrioKo  {
    Aktivitet forste = null;
    Aktivitet siste = null;

    public void settInn(Aktivitet a) {
        if (forste == null) {
           forste = siste = a;
           a.neste = a.forrige = null;
        }
        else {  
            Aktivitet leter = siste;
            while (leter != null && leter.compareTo(a) > 0) {
                leter = leter.forrige;
            }
            if (leter == siste) { // setter inn sist
                siste.neste = a;
                a.forrige = siste;
                siste = a;
                siste.neste = null;
            } else if (leter == null) { // sett inn forst
                a.neste = forste;
                forste.forrige = a;
                forste = a;
                forste.forrige = null;
            }
            else {  // sett inn inne i mellom, bak leter
                a.neste = leter.neste;
                a.forrige = leter;
                leter.neste.forrige = a;
                leter.neste = a;
            }	
        }
    }

    public Aktivitet hentUt( ) {
        if (forste == null) return null;

        Aktivitet temp = forste;
        if (forste == siste) {
	    forste = siste = null;
        } else {		
	    forste = forste.neste;
	    forste.forrige = null;		
        }
        return temp;
    }
}

// Oppgave 2c

class Simulator {
    PrioKo hendelser = new PrioKo();
    int globaltid = 0;

    Simulator(Aktivitet[] alle) {
        for (Aktivitet tg: alle) hendelser.settInn(tg);
    }
    
    public void simuler(int t) {
        while (globaltid < t) {
            Aktivitet lpg = hendelser.hentUt();
            globaltid = lpg.tid;
            lpg.handling();
            hendelser.settInn(lpg);
        }
    }
}

// Oppgave 2d

class Turgaaer extends Aktivitet  {	
    int hastighet;		
    Kryss mittKryss; // Her jeg er eller settes til neste kryss av gaaVidere

    public Turgaaer(Kryss k, int hastighet) {
        super(0);  // Alle starter med tid lik 0
        mittKryss = k; ; this.hastighet = hastighet;
    }
    
    @Override
	public void handling() {
        // Jeg er naa kommet frem til et nytt kryss og
        // jeg skal gaa videre:
        Sti lp = mittKryss.hentTilfeldigSti();   // Tilfeldig sti videre
        mittKryss = lp.finnAndreEnde(mittKryss);  // Dette er krysset jeg kommer til
        tid = tid+lp.beregnGaaTid(hastighet);
    }
}

// Oppgave 2e

public class TestSimulator {
    public static void main(String[] args) { 
        final int ANTKRYSS = 10;
        final int ANTSTIER = 20; 
        final int ANTTRG = 4; // Antall turgaaere    
        Skog nordmarka = new Skog(ANTKRYSS,ANTSTIER);    

        Aktivitet[] alleAkt = new Aktivitet[ANTTRG];
        for (int ind = 0; ind < ANTTRG; ind++) {
	    alleAkt[ind] = new Turgaaer(nordmarka.hentTilfeldigStart(),
					Trekk.trekkInt(20,200));
        }
        // Lager simulator og setter turgaaerene inn:
        Simulator sim = new Simulator(alleAkt); 
        sim.simuler(Trekk.trekkInt(30,480));
    }      	
}

// Oppgave  2f

abstract class Aktivitet2 implements Comparable<Aktivitet>  {	
    private int tid; // Kan ikke akseseres utenfor denne klassen

    protected Aktivitet2(int startTid) { // Bare subklasser kan kalle denne konstruktoren
	if (startTid >= 0) tid = startTid;
	else throw new RuntimeException(" Starttid kan ikke vaere negativ");
    }

    Aktivitet2 neste = null;    // Disse to pekerne skal brukes i samme pakke
    Aktivitet2 forrige = null;

    // Metoden setNyTid er protected saa bare subklasser av
    // aktivitet kan sette ny tid.  Disse kan vaere i en annen pakke/mappe
    protected void setNyTid(int nyTid) {
        if (nyTid <= tid) throw new RuntimeException(" Tiden skal gaa framover");
        tid = nyTid; 	
    }	
    
    // Subklasser  maa kunne hente ut egen tid
    protected int minTid() {
	return tid;
    }

    // Simulatoren (i samme pakke) maa kunne hente ut tiden
    int hentTid() {
	return tid;
    }

    public int compareTo(Aktivitet2 a) {
        return (this.tid - a.tid);
    }
    
    // Bare simulatoren (i samme pakke) skal kalle denne metoden
    abstract void handling();
}