// Konteeksamen i IN1010 og INF1010 våren 2019
// Løsningsforslag og sensorveiledning oppgave 9-10


// Svaret på oppgave 9 må inneholde tegning av arrayen og de riktige objektene.


class Prio<E extends Comparable<E>> {
    Object[] alleO;
     // Om studenten deklarerer E[] alle0, bør dette være like bra.
    int iBruk;
    int maxP, minP;
    
    Prio(int n) {
	// Dette er dessverre ikke lov:  alleO = new E[n];
	// og de bør få litt trekk for det siden akkurat dette har vært forelest.
        // Det er heller ikke lov å skrive  (E[])new Object[n]
        // men dette bør gi full uttelling fordi de har lært å gjøre det sånn, 
	// og det er måten å gjøre det på når E ikke er restriktert.
	// At dette ikke er lov, kan ikke studenten vite.

	// Studenter som har deklarert alleO av typen E[] vil naturlig nok 
	// ikke typekonvertere fra Object til E ved tilordning.
	// Dette er markert i løsningsforslaget der typekonvertering er gjort.

	alleO = new Object[n];

	iBruk = 0;
	maxP = minP = 0; 
    }

    private int bak(int p) {
	if (p == alleO.length-1) return 0;
	return p+1;
    }

    private int foran(int p) {
	if (p == 0) return alleO.length-1;
	return p-1;
    }

    int antall() {
	return iBruk;
    }

    // Det er viktig at taUt returnerer elementet som maxP peker på
    // og at det ikke gjøres noe flytting her.

    E taUt() {
	// NB! Helt greit å anta at iBruk>0.
	E res = (E)alleO[maxP];   // For studenter som har typen E[] på alleO,
	                          // er denne typekonverteringen ikke nødvendig.
	iBruk--;
	maxP = bak(maxP);
	return res;
    }


    // settInn skal være en metode som flytter små elementer og 
    // setter det nye elementet inn på riktig sted.

    void settInn(E e) {
	if (iBruk == 0) {
	    // Spesialbehandling av tom struktur:
	    alleO[0] = e;  iBruk = 1;
	    maxP = minP = 0;
	    return;
	}

	if (iBruk == alleO.length) {
	    // Beholderen er full:
	    if (e.compareTo((E)alleO[minP]) <= 0) { 
		// (Ikke typekonvertering hvis E[]-array.)
		// Det nye elementet er mindre enn alle i beholderen;
		// da er det ingenting å gjøre.
		return;
	    }

	    // Ellers, fjern det minste elementet i beholderen:
	    minP = foran(minP);  iBruk--;
	}
	
	int p = minP;
	minP = bak(minP);
	while (true) {
	    if (p == foran(maxP)) {
		// Det nye elementet er større enn alle i beholderen:
		alleO[bak(p)] = e;  iBruk++;
		return;
	    }

	    if (e.compareTo((E)alleO[p]) <= 0) { 
		// (Ikke typekonvertering hvis E[]-array.)
		// Det nye elementet skal bak p (og vi vet det er ledig plass):
		alleO[bak(p)] = e;  iBruk++;
		return;
	    }

	    // Flytt ned:
	    alleO[bak(p)] = alleO[p];
	    p = foran(p);
	}
    }


    // Det resterende er kun for testformål.

    private void dump() {
	System.out.print(antall() + ":  ");
	for (int i = 0;  i < alleO.length;  i++) {
	    if (i == maxP) System.out.print("M:");
	    if (i == minP) System.out.print("m:");
	    System.out.print(alleO[i] + "  ");
	}
	System.out.println();
    }

    public static void main(String[] arg) {
	Prio<Integer> tab = new Prio<>(6);
	tab.dump();

	tab.settInn(17);  // tab.dump();
	tab.settInn(11);  // tab.dump();
	tab.settInn(11);
	tab.settInn(9);  tab.settInn(1);  tab.settInn(7);
	tab.dump();

	System.out.println("Ut: " + tab.taUt());
	System.out.println("Ut: " + tab.taUt());
	tab.dump();

	tab.settInn(0);   tab.dump();
	tab.settInn(10);  tab.dump();
	tab.settInn(20);  tab.dump();
	tab.settInn(-1);  tab.dump();
    }
}