public class Counter{
    private int base;
    private int length;
    private final int[] counter;




    /**
     * Aufgabe 3 (a)
     */
    public Counter(int length, int base) {
        this.base = base;
        this.length = length;

        //Macht den Counter robust gegen ungültige Werte
        if(length<1 || base<2) {
            throw new IllegalArgumentException("Ungültige Länge oder Basis!");
        }

        //Initialisiert, falls length und base in Ordnung sind, einen Counter der Länge length und setzt alle Stellen auf 0.
        else { 
          counter = new int[length];

          for(int i = 0; i < length; i++) {
              counter[i] = 0;
          }
        }
    }

    /**
     * Aufgabe 3 (b)
     */
    public Counter(int length, int base, boolean random) {
        //Überprüft, ob die Werte für length und base gültig sind.
        if(length<1 || base<2) {
            throw new IllegalArgumentException("Ungültige Länge oder Basis!");
        }

        //Überprüft, ob random false oder true ist. Ist es false, funktioniert dieser Konstruktor wie der erste, ist es true, 
        //wird jeder Stelle des Counters ein zufälliger Wert zugeordnet.
        else {

            this.base = base;
            counter = new int[length];
            if(random == false) {
                for(int i = 0; i < length; i++) {
                    counter[i] = 0;
                }
            }

            else {

              for(int i = 0; i < length; i++) {
                   counter[i] = (int)(Math.random()*(base));
              }
            }
        }

    }




    /**
     * Aufgabe 3 (c)
     * Die Methode nimmt eine bestimmte Position entgegen, erhöht den Wert dieser und setzt alle minderwertigeren Stellen auf 0. Sollte dabei der Wertebereich überschritten
     * werden, wird die nächsthöhere Position um 1 erhöht. Passiert dies auf der letzten Stelle des Arrays, werden alle Stellen auf 0 gesetzt.
     */
    public int inc(int pos) {
        //Verhindert, dass pos kleiner als 0 oder grösser als die Counterlänge ist.
        if(pos<0 || pos>=counter.length) {
            throw new IllegalArgumentException("Ungültiger Wert für pos!");
        }
        int i = pos-1;

        //setzt alle Stellen. die minderwertiger sind als pos, auf 0.
        while(i >= 0) {
            counter[i] = 0;
            i = i--;
        }
        //erhöht den Wert von pos um 1.
        counter[pos]++;

        //Falls pos dabei den Wertebereich übertritt, wird die nächsthöhere eins höher gesetzt und pos auf 0.
        if(counter[pos] >= base) {
          counter[pos+1]++; 
          counter[pos] = 0;
        }

        //Passiert der Überlauf auf der letzten Stelle des Arrays, werden alle Stellen auf 0 gesetzt.
        if(pos == counter.length-1) {
            if(counter[pos] >= base) {
                counter[i] = 0;
            }
        }

        return counter[pos];
    }

    /**
     * (d)
     * Erhöht die Werte aller Stellen um 1, unter Beachtung der Base, wie bei int inc(int pos).
     */
    public int inc() {
        int i = 0;

        //Erhöht alle Stellen um 1
        for(i = 0; i < length; i++) {
            counter[i]++;
        }

        //Falls der Wertebereich überschritten wird, wird die nächsthöhere erneut um 1 erhöht.
        if(counter[i] == base) {
            counter[i+1]++;
        }

        //Setzt alle Stellen auf 0, falls der Überlauf an letzter Stelle eintritt.
        if(i == counter.length-1) {
            if(counter[i] >= base) {
                counter[i] = 0;
            }
        }

        return counter[i];
    }

    /**
     * (e)
     * gibt den aktuellen Stand des Zählers zurück und erstellt dazu ein Hilfsarray.
     */
    public int[] value() {
        int[] help = new int[counter.length];

        for(int i = 0; i < counter.length; i++) {
            help[i] = counter[i];
        }

        return help;
    }
}