// Pruebas de la parte opcional: el parser descendente recursivo acepta exactamente las cadenas
// de tokens que genera la gramática machines/expr.cfg, respeta la precedencia y lee cada token
// una vez.
#include <cassert>
#include <cstddef>
#include <iostream>
#include <set>
#include <stdexcept>
#include <string>
#include <vector>

#include "cfg.h"
#include "expr.h"
#include "pda.h"

namespace {

// Una cadena sobre {a, +, *, (, )} como lista de tokens: cada a es un número.
std::vector<Token> tokens_of(const std::string& w) {
    std::vector<Token> tokens;
    for (std::size_t i = 0; i < w.size(); i++) {
        switch (w[i]) {
            case 'a': tokens.push_back({TokenKind::Number, "1", i}); break;
            case '+': tokens.push_back({TokenKind::Plus, "+", i}); break;
            case '*': tokens.push_back({TokenKind::Star, "*", i}); break;
            case '(': tokens.push_back({TokenKind::LParen, "(", i}); break;
            default: tokens.push_back({TokenKind::RParen, ")", i}); break;
        }
    }
    tokens.push_back({TokenKind::End, "", w.size()});
    return tokens;
}

bool parses(const std::vector<Token>& tokens) {
    try {
        parse(tokens);
    } catch (const std::runtime_error&) {
        return false;
    }
    return true;
}

Parsed evaluate(const std::string& text) {
    return parse(lex(text));
}

}  // namespace

int main() {
    // El parser y la gramática coinciden en todas las cadenas de tokens de longitud a lo sumo 6.
    Cfg g = load_cfg("machines/expr.cfg");
    std::size_t n = 6;
    std::set<std::string> generated = strings_up_to(g, n);
    std::size_t total = 0;
    for (const std::string& w : all_strings(g.terminals, n)) {
        assert(parses(tokens_of(w)) == (generated.count(w) > 0));
        total++;
    }

    // El lexer.
    std::vector<Token> tokens = lex(" 12+(3 *45) ");
    assert(tokens.size() == 8);
    assert(tokens[0].kind == TokenKind::Number && tokens[0].text == "12" && tokens[0].pos == 1);
    assert(tokens[5].kind == TokenKind::Number && tokens[5].text == "45");
    assert(tokens[7].kind == TokenKind::End);
    assert(lex("").size() == 1);

    // Precedencia y agrupación: los ejemplos de los apuntes.
    assert(evaluate("2 + 3 * 4").value == 14 && evaluate("2 + 3 * 4").tree == "(2 + (3 * 4))");
    assert(evaluate("(2 + 3) * 4").value == 20 && evaluate("(2 + 3) * 4").tree == "((2 + 3) * 4)");
    assert(evaluate("2 + 3 + 4").tree == "((2 + 3) + 4)");
    assert(evaluate("2 * 3 * 4").tree == "((2 * 3) * 4)");
    assert(evaluate("((7))").value == 7 && evaluate("((7))").tree == "7");
    assert(evaluate("2*(3+4)*5+1").value == 71);

    // Tiempo lineal: la cantidad de llamadas se cuenta a partir de los tokens, sin retroceder.
    // Son 3 por la expresión completa y por cada paréntesis que abre, 2 por cada + y 1 por cada *.
    for (const std::string& w : generated) {
        std::size_t calls = 0;
        parse(tokens_of(w), &calls);
        std::size_t open = 0;
        std::size_t plus = 0;
        std::size_t star = 0;
        for (char c : w) {
            open += c == '(';
            plus += c == '+';
            star += c == '*';
        }
        assert(calls == 3 * (1 + open) + 2 * plus + star);
        assert(calls <= 3 * w.size());
    }

    // Errores.
    for (const std::string text : {"", "2 +", "+ 2", "2 + * 3", "(2 + 3", "2 3", "()", "2 )"}) {
        assert(!parses(lex(text)));
    }
    bool thrown = false;
    try {
        lex("2 $ 3");
    } catch (const std::runtime_error&) {
        thrown = true;
    }
    assert(thrown);

    std::cout << "test_expr: ok (" << total << " cadenas de tokens contra la gramática)\n";
}
