#ifndef PARSER_H  // voorkomt dat dit bestand meerdere keren
#define PARSER_H  // ge-include wordt

#include <vector>
#include <string>

#include "automaton.h"

class Parser {
    public:
        /**
         * @brief Constructor voor een Parser object
         * Deze constructor initialiseert de private variabelen
         * @param expression De reguliere expressie die moet worden geparsed
         * Deze wordt in de private variabele expression gezet
         */
        Parser(std::string expression);

        /**
         * @brief Deze functie start het parsen door expr() aan te roepen
         * @return Automaton Een automaat wordt gereturned die de eindige
         * automaat van de reguliere expressie voorstelt als het parsen goed ging
         * Als het parsen fout is gegaan dan wordt indirect een lege automaat gereturned
         * via expr(). Als we zien dat niet de hele expressie is geparsed wordt ook een
         * lege automaat teruggegeven.
         */
        Automaton parse();

    private:
        /**
         * @brief De index houdt bij wat de huidige token is in de expressie
         */
        int index;

        /**
         * @brief De meegegeven expressie bij de constructor, dit is de reguliere
         * expressie die moet worden geparsed door de parser.
         */
        std::string expression;

        /**
         * @brief De lengte van de meegegeven expressie
         */
        int length;

        /**
         * @brief Het karakter dat op het huidige moment wordt geparsed 
         */
        char currentToken;

        /**
         * @brief Houdt bij of er een error is ontdekt
         * Nodig om makkelijk gelijk te stoppen met de recursies bij een error
         */
        bool error;

        /**
         * @brief Zet een nieuwe token die moet worden geparsed uit expression
         * in currentToken. Als er geen verder tokens meer zijn, dan wordt
         * currentToken een $, zodat er niks fout gaat.
         */
        void nextToken();

        /**
         * @brief Geeft terug of de hele expressie geparsed is
         */
        bool isFinished() const;

        /**
         * @brief Geeft terug of het karakter een letter is
         */
        bool isLetter(char const character) const;

        /**
         * @brief Geeft terug of het karakter een openingshaakje is
         */
        bool isOpeningPar(char const character) const;

        /**
         * @brief Geeft terug of het karakter een sluitingshaakje is
         */
        bool isClosingPar(char const character) const;

        /** 
         * @brief Geeft terug of het karakter een ster is
         */
        bool isStar(char const characater) const;

        /**
         * @brief Parse functie voor een expressie
         * <expr> := <term> [ | <expr> ]
         * @return Automaton De automaat die eruit komt na het parsen
         */
        Automaton expr();

        /**
         * @brief Parse functie voor een term
         * <term> := <fact> [ <term> ]
         * @return Automaton De automaat die eruit komt na het parsen
         */
        Automaton term();

        /**
         * @brief Parse functie voor een fact en een letter
         * <fact> := <lett> [ * ] | ( <expr> ) [ * ]
         * <lett> := a | b | ... | z
         * @return Automaton De automaat die eruit komt na het parsen
         */
        Automaton fact();

};

#endif