#ifndef QPDFTOKENIZER_PRIVATE_HH
#define QPDFTOKENIZER_PRIVATE_HH

#include <qpdf/QPDFTokenizer.hh>

namespace qpdf
{

    class Tokenizer
    {
      public:
        Tokenizer();
        Tokenizer(Tokenizer const&) = delete;
        Tokenizer& operator=(Tokenizer const&) = delete;

        // Methods to support QPDFTokenizer. See QPDFTokenizer.hh for detail. Some of these are used
        // by Tokenizer internally but are not accessed directly by the rest of qpdf.

        void allowEOF();
        void includeIgnorable();
        void presentCharacter(char ch);
        void presentEOF();
        bool betweenTokens();

        // If a token is available, return true and initialize token with the token, unread_char
        // with whether or not we have to unread the last character, and if unread_char, ch with the
        // character to unread.
        bool getToken(QPDFTokenizer::Token& token, bool& unread_char, char& ch);

        // Read a token from an input source. Context describes the context in which the token is
        // being read and is used in the exception thrown if there is an error. After a token is
        // read, the position of the input source returned by input->tell() points to just after the
        // token, and the input source's "last offset" as returned by input->getLastOffset() points
        // to the beginning of the token.
        QPDFTokenizer::Token readToken(
            InputSource& input,
            std::string const& context,
            bool allow_bad = false,
            size_t max_len = 0);

        // Calling this method puts the tokenizer in a state for reading inline images. You should
        // call this method after reading the character following the ID operator. In that state, it
        // will return all data up to BUT NOT INCLUDING the next EI token. After you call this
        // method, the next call to readToken (or the token created next time getToken returns true)
        // will either be tt_inline_image or tt_bad. This is the only way readToken returns a
        // tt_inline_image token.
        void expectInlineImage(InputSource& input);

        // Read a token from an input source. Context describes the context in which the token is
        // being read and is used in the exception thrown if there is an error. After a token is
        // read, the position of the input source returned by input->tell() points to just after the
        // token, and the input source's "last offset" as returned by input->getLastOffset() points
        // to the beginning of the token. Returns false if the token is bad or if scanning produced
        // an error message for any reason.
        bool nextToken(InputSource& input, std::string const& context, size_t max_len = 0);

        // The following methods are only valid after nextToken has been called and until another
        // QPDFTokenizer method is called. They allow the results of calling nextToken to be
        // accessed without creating a Token, thus avoiding copying information that may not be
        // needed.

        inline QPDFTokenizer::token_type_e
        getType() const
        {
            return this->type;
        }
        inline std::string const&
        getValue() const
        {
            return (this->type == QPDFTokenizer::tt_name || this->type == QPDFTokenizer::tt_string)
                ? this->val
                : this->raw_val;
        }
        inline std::string const&
        getRawValue() const
        {
            return this->raw_val;
        }
        inline std::string const&
        getErrorMessage() const
        {
            return this->error_message;
        }

      private:
        bool isSpace(char);
        bool isDelimiter(char);
        void findEI(InputSource& input);

        enum state_e {
            st_top,
            st_in_hexstring,
            st_in_string,
            st_in_hexstring_2nd,
            st_name,
            st_literal,
            st_in_space,
            st_in_comment,
            st_string_escape,
            st_char_code,
            st_string_after_cr,
            st_lt,
            st_gt,
            st_inline_image,
            st_sign,
            st_number,
            st_real,
            st_decimal,
            st_name_hex1,
            st_name_hex2,
            st_before_token,
            st_token_ready
        };

        void handleCharacter(char);
        void inBeforeToken(char);
        void inTop(char);
        void inSpace(char);
        void inComment(char);
        void inString(char);
        void inName(char);
        void inLt(char);
        void inGt(char);
        void inStringAfterCR(char);
        void inStringEscape(char);
        void inLiteral(char);
        void inCharCode(char);
        void inHexstring(char);
        void inHexstring2nd(char);
        void inInlineImage(char);
        void inTokenReady(char);
        void inNameHex1(char);
        void inNameHex2(char);
        void inSign(char);
        void inDecimal(char);
        void inNumber(char);
        void inReal(char);
        void reset();

        // Lexer state
        state_e state;

        bool allow_eof{false};
        bool include_ignorable{false};

        // Current token accumulation
        QPDFTokenizer::token_type_e type;
        std::string val;
        std::string raw_val;
        std::string error_message;
        bool before_token;
        bool in_token;
        char char_to_unread;
        size_t inline_image_bytes;
        bool bad;

        // State for strings
        int string_depth;
        int char_code;
        char hex_char;
        int digit_count;
    };

} // namespace qpdf

#endif // QPDFTOKENIZER_PRIVATE_HH