#include <iostream>
#include <any>

#define POG_DEBUG_TOKENIZER
#define POG_DEBUG_PARSER
#include "pog/pog.h"

using namespace pog;
using Value = std::any;

int main(int argc, char const *argv[])
{
    Parser<Value> parser;

    parser.token("\\s+");
    parser.token("test").symbol("test").action(
        [](auto&& sv) {
            return sv;
        });

    parser.rule("TEST_LIST")
        .production("TEST_LIST", "TEST",
            [](auto&& p){ return std::move(p); })
        .production(
            [](auto&& p){ return std::move(p); })
        ;

    parser.rule("TEST")
        .production("test", 
            [](auto&& p){ return std::move(p); })
        ;

    parser.set_start_symbol("TEST_LIST");
    std::cout << parser.prepare().to_string() << std::endl;

    try{
        auto v = parser.parse(std::cin);
    }
    catch (const SyntaxError& err) {
        //HtmlReport html(parser);
        //html.save("parser.html");
        std::cerr << err.what()  << std::endl;
    }

    return 0;
}

test                                                                                                                                                                                                                                                                                        
^Z                                                                                                                                                                                                                                                                                          
[tokenizer] Matched 'test' with token 'test' (index 2)                                                                                                                                                                                                                                      
[parser] Tokenizer returned new token with symbol 'test'                                                                                                                                                                                                                                    
[parser] Top of the stack is state 0                                                                                                                                                                                                                                                        
[parser] Reducing by rule 'TEST_LIST -> <eps>'                                                                                                                                                                                                                                              
[parser] Pushing state 1                                                                                                                                                                                                                                                                    
[parser] Reusing old token with symbol 'test'                                                                                                                                                                                                                                               
[parser] Top of the stack is state 1                                                                                                                                                                                                                                                        
[parser] Shifting state 2                                                                                                                                                                                                                                                                   
[tokenizer] Matched '                                                                                                                                                                                                                                                                       
' with token '\s+' (index 1)                                                                                                                                                                                                                                                                
[tokenizer] Reached end of input                                                                                                                                                                                                                                                            
[tokenizer] Matched '' with token '$' (index 0)                                                                                                                                                                                                                                             
[tokenizer] At the end of input                                                                                                                                                                                                                                                             
[parser] Tokenizer returned new token with symbol '@end'                                                                                                                                                                                                                                    
[parser] Top of the stack is state 2                                                                                                                                                                                                                                                        
[parser] Reducing by rule 'TEST -> test'                                                                                                                                                                                                                                                    
[parser] Pushing state 3                                                                                                                                                                                                                                                                    
[parser] Reusing old token with symbol '@end'                                                                                                                                                                                                                                               
[parser] Top of the stack is state 3                                                                                                                                                                                                                                                        
[parser] Reducing by rule 'TEST_LIST -> TEST_LIST TEST'                                                                                                                                                                                                                                     
Assertion failed: false && "Reduction happened but corresponding GOTO table record is empty", file external\pog\include\pog/parser.h, line 206