/**
 * De Toren bestaat uit een reek getallen die je van klein naar groot moeten bouwen.
 * In het begin staat de toren in een foute volgorde. De speler krijgt dan telkens een getal aangeboden
 * en moet dit getal ofwel in de toren plaatsen ofwel weg gooien.
 * Wanneer hij/zij het weggooit, krijgt hij wel een strafbeurt.
 *
 * Dit is vooral een oefening op arrays en de for-lus.
 * Deze klasse werkt volledig op uitzondering van de 5 laatste methodes. Die moet de student zelf implementeren?
 *
 *
 * @author Kris Aerts
 * @version 14/1/2013
 */
public class Toren
{
    private int aantal, beurten; // aantal vakjes in de toren en aantal beurten
    private int[] toren;  // de vakjes in de toren
    private int bovengrens; // de bovengrens voor de getallen in de toren

    private int volgende; // het volgende getal dat de speler krijgt aangeboden

    /**
     * Constructor for objects of class Toren met hoogte 8 en bovengrens 40
     */
    public Toren()
    {
        aantal = 10;
        bovengrens = 40;
        init();
    }

    /**
     * Constructor for objects of class Toren
     *
     * @param hoogte de hoogte van de toren (= het aantal vakjes)
     * @param bovengrens een bovengrens voor de getallen in de toren
     */
    public Toren(int aantal, int bovengrens) {
        this.aantal = aantal;
        this.bovengrens = bovengrens;
    }

// een eerste setter: de toren initialiseren (afhankelijk van aantal en bovengrens)
    /**
     * initialiseer de toren
     *
     */
    public void init() {
        toren = new int[aantal];
        for (int i=0; i<aantal; i++) {
           int getal = 1+(int)(Math.random()*bovengrens);
           toren[i] = getal;
        }

        volgende = 1+(int)(Math.random()*bovengrens);
    }

// getters
    /**
     * converteer de toren in een string
     *
     * @return de toren in tekstvorm
     */
    public String toString() {
        String uitvoer = "De toren na " + beurten + " beurten\n\n";
        for (int i=0; i<aantal; i++) {
           uitvoer = uitvoer + toren[i] + " ";
        }
        return uitvoer;
    }

    /**
     * hoe hoog is de toren?
     *
     * @return het aantal vakjes van de toren
     */
    public int getHoogte() {
        return aantal;
    }

    /**
     * wat is de bovengrens voor de getallen in de toren?
     *
     * @return de bovengrens
     */
    public int getBovengrens() {
        return bovengrens;
    }

    /**
     * hoeveel beurten heeft de speler al gespeeld?
     *
     * @return het aantal beurten (inclusief de strafbeurten)
     */
    public int getBeurten() {
       return beurten;
    }

    /**
     * wat is het volgende getal dat de speler in de toren mag plaatsen?
     *
     * @return het volgende getal (van 1 tot de bovengrens)
     */
    public int getVolgende() {
       return volgende;
    }

    /**
     * geef het getal op de opgegeven positie
     *
     * @param positie de positie: 1 is het hoogste en getHoogte() is het laagste
     *
     */
    public int getGetal(int positie) {
       if (positie < 0 || positie > aantal) return -1;

       return toren[positie-1]; // want de array telt van 0 tot aantal-1
    }

// setters
    /**
     * gooi het huidige getal weg.
     * Dit telt voor 2 beurten.
     */
    public void gooiWeg() {
        beurten = beurten + 2;
        volgende = 1+(int)(Math.random()*bovengrens);
    }

    /**
     * plaats het huidige getal op de opgegeven positie.
     * Dit telt voor 1 beurt.
     *
     * @param positie de plaats waar het huidige getal moet komen, >= 1 && <= aantal/hoogte
     */
    public void plaatsOp(int positie) {
       if (positie < 1 || positie > aantal) return;

       beurten++;
       toren[positie-1] = volgende;
       volgende = 1+(int)(Math.random()*bovengrens);
    }


// de oefeningen
    /**
     * geeft de som van de getallen in de toren
     *
     * @return de som
     */
    public int getSom() {
      int som = 0;
      for (int i = 0; i < aantal; i++)
      {
          som += toren[i];
      }
      return som;
    }
    /**
     * is de toren helemaal correct?
     *
     * @return true wanneer de blokjes stijgende zijn
     */
    public boolean isCorrect() {
       boolean correct = true;
       for(int i = 0; i < aantal - 1; i++)
       {
           if(toren[i] > toren[i + 1])
               correct = false;
       }
       return correct;
    }
    /**
     * geeft de grootste sprong in de toren),
     * waarbij  we  met  sprong  het  verschil  tussen  2  opeenvolgende  blokken bedoelen
     *
     * @return de grootste sprong
     */
    public int getGrootsteSprong() {
        int grootsteSprong = 0;
        for(int i = 0; i < aantal - 1; i++)
        {
           if(Math.abs(toren[i] - toren[i + 1]) > grootsteSprong)
           {
              grootsteSprong = Math.abs(toren[i] - toren[i + 1]);
           }
        }
        return grootsteSprong;
    }
    /**
     * geeft de gemiddelde sprong in de toren),
     * waarbij  we  met  sprong  het  verschil  tussen  2  opeenvolgende  blokken bedoelen
     *
     * @return de gemiddelde sprong
     */
    public int getGemiddeldeSprong() {
        int som = 0;
        for(int i = 0; i < aantal - 1; i++)
        {
           som += Math.abs(toren[i] - toren[i + 1]);
        }
        return som / (aantal - 1);
    }
    /**
     * geeft het aantal blokjes dat fout staat (dus kleiner dan het vorige)
     *
     * @return de aantal foute
     */
    public int getAantalFouten() {
        int aantalFouten = 0;
        for(int i = 0; i < aantal - 1; i++)
        {
           if(toren[i] > toren[i + 1])
               aantalFouten++;
        }
        return aantalFouten;
    }
    /**
     * geeft de lengte van het langste stuk dat correct is
     * (waarbij de getallen dus stijgend zijn).
     *
     * @return de lengte
     */
    public int getLangsteCorrect() {
        int stappenZonderFout = 0;
        int langsteStappenZonderFout = 0;
        for(int i = 0; i < aantal - 1; i++)
        {
           if(toren[i] <= toren[i + 1])
              stappenZonderFout++;
           else
           {
              stappenZonderFout = 0;
           }
           if(stappenZonderFout > langsteStappenZonderFout)
              langsteStappenZonderFout = stappenZonderFout;
        }
        return langsteStappenZonderFout;
    }
}