#pragma once
/*
 * Created by Brett on 17/11/23.
 * Licensed under GNU General Public License V3.0
 * See LICENSE file for license detail
 */

#ifndef BRAINFUCK_MISC_BF_TOKENIZER_H
#define BRAINFUCK_MISC_BF_TOKENIZER_H

#include <vector>
#include <string>
#include <optional>

enum class bf_token
{
    INC_DP,
    DEC_DP,
    INC_DV,
    DEC_DV,
    PRINT,
    READ,
    OPEN,
    CLOSE
};

struct token_t
{
    bf_token type;
    int64_t offset;
    std::optional<uint64_t> name = {};
    
    explicit token_t(bf_token type, int64_t offset = 1): type(type), offset(offset)
    {}
    
    
};

typedef std::optional<std::reference_wrapper<const token_t>> optional_token;

class tokenizer
{
    private:
        std::vector<token_t> tokens;
        size_t conditionalCount = 0;
        size_t currentIndex = 0;
        
        void tokenize(const std::string& program);
        
        void bf_name();
    
    public:
        explicit tokenizer(const std::string& program)
        {
            tokenize(program);
            bf_name();
        }
        
        inline bool hasNext(){
            return currentIndex < tokens.size();
        }
        
        inline size_t advance(){
            return currentIndex++;
        }
        
        inline const token_t& next() {
            return tokens[advance()];
        }
        
        inline const token_t& peek(){
            return tokens[currentIndex];
        }
        
        void print(size_t index);
        inline void print(){
            print(currentIndex);
        }
};

#endif //BRAINFUCK_MISC_BF_TOKENIZER_H