/**
 * Diese Klasse simuliert ein Hanoi-Spiel mit Hilfe der Stapel-, Element- und
 * Scheiben-Klasse. Die Stapelklasse wurde dabei leicht verändert, sodass die
 * Methode top() nicht mehr den Inhalt eines Elementes, sondern das Element selbst
 * zurückgibt.
 * Diese Klasse dient der Übung von Rekursionen.
 *
 * @author C. Rauwolf
 * @version 10.11.2014
 */
public class Hanoi
{
    private Stack<Scheibe> turm1, turm2, turm3;

    /**
     * Erzeugt drei Stapel und n Scheiben, welche in der richtigen Reihenfolge
     * auf den 1. Stapel gelegt werden (von groß nach klein).
     *
     * @param  n   Höhe des Anfangsturms
     */
    public Hanoi(int n)
    {
        turm1= new Stack<Scheibe>();
        turm2= new Stack<Scheibe>();
        turm3= new Stack<Scheibe>();

        // Erzeugt n Scheiben und legt sie auf den 1. Stapel
        for(int i = n; i>0; i--){
            Scheibe neueScheibe = new Scheibe(i);
            turm1.push(neueScheibe);
        }
    }

    /**
     * Die Methode bewegt die oberste Scheibe von Turm "start" nach Turm "ziel".
     *
     * @param  start        Index des Startstapels
     * @param  ziel         Index des Zielstapels
     */
    public void move(int start, int ziel){
        Stack<Scheibe> tVon, tNach;
        // Hier werden die Start- und Zielreferenzen gesetzt um danach
        // einfacher tauschen zu können.
        switch(start){
            case 1: tVon=turm1; break;
            case 2: tVon=turm2; break;
            case 3: tVon=turm3; break;
            default:tVon=turm1; break;
        }
        switch(ziel){
            case 1: tNach=turm1; break;
            case 2: tNach=turm2; break;
            case 3: tNach=turm3; break;
            default:tNach=turm1; break;
        }
        // Eigentlicher Tausch
        Scheibe tmpScheibe = tVon.top();
        tNach.push(tmpScheibe);
        tVon.pop();
    }

    /**
     * Die Methode gibt den Inhalt aller drei Stapel in der Konsole aus.
     */
    public void printStacks(){
        // zum Zwischenspeichern der Werte jedes Turmes
        String tmpString;
        Stack<Scheibe> tmpStack = new Stack<Scheibe>();
        Stack<Scheibe> aktTurm;
        Scheibe tmpScheibe;


        for(int i=0; i<3; i++){
            System.out.print((i+1)+"ter Stapel: |-");
            tmpString = "";

            switch(i){
                case 0: aktTurm=turm1; break;
                case 1: aktTurm=turm2; break;
                case 2: aktTurm=turm3; break;
                default:aktTurm=turm1; break;
            }

            // Alle Scheibengrößen des aktuellen Stapels ausgeben
            while(!aktTurm.isEmpty()){
                tmpScheibe=aktTurm.top();
                tmpStack.push(tmpScheibe);
                tmpString+=tmpScheibe.getGroesse();
                aktTurm.pop();
            }

            for(int s=tmpString.length()-1; s>=0; s--){
                System.out.print(tmpString.charAt(s));
            }

            // Aktuellen Stapel aus tmpStapel "wiederherstellen"
            while(!tmpStack.isEmpty()){
                aktTurm.push(tmpStack.top());
                tmpStack.pop();
            }

            System.out.println("");
        }
        System.out.println("");
    }


    /**
     * Gibt die Anzahl der Schritte aus die benötigt werden um einen Turm mit
     * "anzScheiben" vielen Scheiben von einen auf einen anderen Stapel zu legen.
     *
     * @param   anzScheiben   Höhe des Anfangsturms
     * @return  Minimale Anzahl der benötigten Züge
     */
    public int getNumberOfMoves(int anzScheiben){
        // Abbruchbedingung (für welchen Wert können wir das Problem lösen?)
        if(anzScheiben == 1) return 1;
        // Rekursionsschritt (auf welches einfachere Problem können wir unser Problem zurückführen?)
        return getNumberOfMoves(anzScheiben - 1) * 2 + 1;
    }

    /**
     * Die Methode soll einen Turm mit "anzScheiben" vielen Scheiben mit Hilfe
     * eines Hilfstapels "hilf" vom Spapel "start" auf den Stapel "ziel" überführen
     * und dabei die Spielregeln des Hanoi-Spiels berücksichtigen. Die Lösung soll
     * rekursiv sein (Zusatz: Es ist auch eine iterative Lösung möglich).
     *
     * @param  anzScheiben  Gibt an wie hoch der Turm ist, der verlegt werden soll
     * @param  start        Index des Startstapels
     * @param  hilf         Index des Hilfstapels
     * @param  ziel         Index des Zielstapels
     */
    public void solve(int anzScheiben, int start, int hilf, int ziel){


    }

}