/* Skisse til program som l?ser spillet 'T?rnet i Hanoi'

   Oppgaven g?r ut p? ? skrive kode som mangler.

   1. Fullf?r klassene som oppretter datamodellen av spillet
      Plate, Pinne, Stabel

   2. Skriv den rekursive l?sningsmetoden flyttRek

   3. Utfordring:
      Fullf?r den iterative l?sningmetoden flyttIter.
      Algoritmebeskrivelsen er hentet fra
      http://www.geeksforgeeks.org/iterative-tower-of-hanoi/

*/


public class Oppgave {

    /* Parameter til programmet: antall ringer som skal flyttes
       Startes med kommandoen 'java Oppgave n', der n er antall plater
     */
    public static void main(String[] args) {
        int antallRinger = Integer.parseInt(args[0]);
        Hanoi spill = new Hanoi();
        
        /* Skal flytte alle platene
             fra pinne "Fra" til pinne "Til" via pinne "Via". */
         
        Pinne fra = new Pinne("Fra");
	for (int d=antallRinger; d > 0; d--) {
	    Plate p = new Plate(d);
            fra.leggP?Toppen(new Plate(d));
	}

        Pinne til = new Pinne("Til");
        Pinne via = new Pinne("Via");

        spill.flyttIter(antallRinger, fra, via, til);

        System.out.println("Antall flytt: " + spill.antFlytt() );}
		
}

class Hanoi {
    static int antallFlytt = 0;
    static int antallPlater;
    
    public int antFlytt() { return antallFlytt; }

    /*
    Iterative Algorithm:

    1. Calculate the total number of moves required i.e. "pow(2, n)- 1"
                 here n is number of disks.
    2. If number of disks (i.e. n) is even then interchange destination 
       pole and auxiliary pole.
    3. for i = 1 to total number of moves:
     if i%3 == 1:
        legal movement of top disk between source pole and 
        destination pole
     if i%3 == 2:
        legal movement top disk between source pole and 
        auxiliary pole        
     if i%3 == 0:
        legal movement top disk between auxiliary pole 
        and destination pole 

    */


    public void flyttIter(int ant, Pinne fra, Pinne via, Pinne til) {
        /* 
           ant - number of disks
           fra - source pole
           til - destination pole
           via - auxiliary pole */

        //  1. Calculate the total number of moves required i.e. pow(2, n)- 1

	// erstatt denne koden med et kall p? en rekursiv metode som beregner
	// 2^ant, 2 opph?yd i ant, alts? skal kallet
	// antallFlytt = toOpph?ydI(ant) - 1;
	// gi samme svar som:

        int antallFlytt = 1; 
        for (int i = 0; i<ant; i++) { antallFlytt = antallFlytt*2; }
        antallFlytt--;

        System.out.println(antallFlytt);

        // 2. If number of disks (i.e. ant) is even then interchange destination 
        //       pole and auxiliary pole.

        if (ant  % 2 == 0) {
            Pinne tmp = til;
            til = via;
            via = tmp;
        }

	/* For hver av de tre tilfellene, er det to muligheter, men bare
           ¨Śn flytting er lovlig, nemlig den som ikke f?rer til at en st?rre
	   plate blir liggende opp? en mindre.
	*/

        for (int i = 1; i <= antallFlytt; i++) {

            if (i%3 == 1) {
                // legal movement of top disk between source pole and 
                // destination pole

            } else
            if (i%3 == 2) {
                // legal movement top disk between source pole and 
                // auxiliary pole        

            } else
            if (i%3 == 0) {
                // legal movement top disk between auxiliary pole 
                // and destination pole 

            }
        }
    }

    /* Her skjer selve flyttingen av hver enkelt plate */
    public void flytt1(Pinne fra, Pinne til) {
        antallFlytt++;
        System.out.println("Flytter en plate fra pinne " + fra.hentNavn() + " til pinne " + til.hentNavn());

        // kode som oppdaterer datastrukturen (de 3 pinnene)
    }

    public void flyttRek(int ant, Pinne fra, Pinne via, Pinne til) {
	// Denne laget vi i forelesningen, men det er god trening ? repetere det.
	// Husk basistilfelle (rekursjonsbunn)

    }
}

class Plate implements Comparable<Plate> {

    Plate (int d) {}

    public int compareTo(Plate p) { return 0; }

    // Fullf?r konstrukt?r og compareTo, samt resten av klassen

}


class Stabel < T extends Comparable<T> > {

    // skriv hele klassen, uferdige metoder antydet for at skissen skal kompilere

    // returnerer, men fjerner ikke, ?verste objekt
    public T hentTopp() {
	return null;
    } 

    // push()
    public T taAv() {
       return null; 
    }

    // pop(T t)
    public void leggP?Toppen(T t) { }
}

class Pinne extends Stabel<Plate> {

    protected String navn;
    
    Pinne(String n) { navn = n; }

    // metode som sjekker om denne pinnen kan ta imot topplaten fra p
    public boolean kanTaImotToppFraPinne( Pinne p ) {
	return true;
    }

    public String hentNavn() { return navn; }
}