#include <string>
#include <vector>
using namespace std;

#include "include/test.h"

#include "../src/include/tokenize.h"

int main() {
    _TEST_PRESENTATION("Lexer");

    /* All tokens */
    vector<string> inputs = {
        "int", "a", "=", "x", "++", "--", "==", "&&", "||", "<", ">", "<=", ">=", "!=", "!", "*", "/", "%", "=", ";", "(", ")", "{", "}", "if", "else", "while", "for", "break", "continue", "return", ","
    };

    vector<TokenType> expected_types = {
        TokenType::Identifier, TokenType::Identifier, TokenType::Equal, TokenType::Identifier,
        TokenType::DoublePlus, TokenType::DoubleMinus, TokenType::DoubleEqual, TokenType::Land,
        TokenType::Lor, TokenType::Lt, TokenType::Gt, TokenType::Leq, TokenType::Geq, TokenType::NotEqual,
        TokenType::Not, TokenType::Star, TokenType::Slash, TokenType::Percent, TokenType::Equal,
        TokenType::Semicolon, TokenType::LParenthese, TokenType::RParenthese, TokenType::LCurlyBracket,
        TokenType::RCurlyBracket, TokenType::If, TokenType::Else, TokenType::While, TokenType::For,
        TokenType::Break, TokenType::Continue, TokenType::Return, TokenType::Comma
    };

    for (size_t i = 0; i < inputs.size(); i++) {
        vector<Token> tokens = tokenize({ inputs[i] });
        _TEST_ASSERT(tokens.size() == 1, _debug_get_token_type_name(expected_types[i]).c_str(), false);
        _TEST_ASSERT(tokens[0].type == expected_types[i], _debug_get_token_type_name(expected_types[i]).c_str(), true);
    }

    /* Complex input */
    {
        string input = "int a = x+++7;";

        vector<Token> tokens = tokenize({ input });

        _TEST_ASSERT(
            _TEST_NO_EXCEPTION(tokens.size() == 8),
            "Il devrait y avoir 8 tokens",
            false
        )

        _TEST_ASSERT(
            _TEST_NO_EXCEPTION(tokens[0].type == TokenType::Identifier),
            "Le premier token devrait être de type 'Identifier'",
            false
        )
        _TEST_ASSERT(
            _TEST_NO_EXCEPTION(get<string>(tokens[0].data) == "int"),
            "Les données du premier token devraient être 'Int'",
            false
        )

        _TEST_ASSERT(
            _TEST_NO_EXCEPTION(tokens[1].type == TokenType::Identifier),
            "Le deuxième token devrait être un 'Identifiant'",
            false
        )
        _TEST_ASSERT(
            _TEST_NO_EXCEPTION(get<string>(tokens[1].data) == "a"),
            "Les données du deuxième token devraient être 'a'",
            false
        )

        _TEST_ASSERT(
            _TEST_NO_EXCEPTION(tokens[2].type == TokenType::Equal),
            "Le troisième token devrait être 'Equal'",
            false
        )

        _TEST_ASSERT(
            _TEST_NO_EXCEPTION(tokens[3].type == TokenType::Identifier),
            "Le quatrième token devrait être un 'Identifiant'",
            false
        )
        _TEST_ASSERT(
            _TEST_NO_EXCEPTION(get<string>(tokens[3].data) == "x"),
            "Les données du quatrième token devraient être 'x'",
            false
        )

        _TEST_ASSERT(
            _TEST_NO_EXCEPTION(tokens[4].type == TokenType::DoublePlus),
            "Le cinquième token devrait être 'DoublePlus'",
            false
        )

        _TEST_ASSERT(
            _TEST_NO_EXCEPTION(tokens[5].type == TokenType::Plus),
            "Le cinquième token devrait être 'Plus'",
            false
        )

        _TEST_ASSERT(
            _TEST_NO_EXCEPTION(tokens[6].type == TokenType::Litteral),
            "Le premier token devrait être de type 'Litteral'",
            false
        )
        _TEST_ASSERT(
            _TEST_NO_EXCEPTION(get<int>(tokens[6].data) == 7),
            "Les données du premier token devraient être '7'",
            false
        )

        _TEST_ASSERT(
            _TEST_NO_EXCEPTION(tokens[7].type == TokenType::Semicolon),
            "Le cinquième token devrait être 'Semicolon'",
            false
        )

        _TEST_ASSERT(true, "Triple plus", true)
    }

    /* Incorrect input */
    {
        string input = "int a = 10 @;";

        _TEST_ASSERT(
            _TEST_IS_EXCEPTION(tokenize({ input }), ErrorType::UnknownToken),
            "Token invalide",
            true
        )
    }

    return 0;
}