#include "../test.h"
#include "arc/std/errno.h"
#include "arc/std/parser.h"
#include "arc/std/lexer.h"
#include "arc/std/vector.h"
#include "arc/std/parser/parserlang.h"
#include <stddef.h>

#define LAMBDA        ARC_PARSER_TAG_LAMBDA
#define CHAR          ARC_LEXER_TOKEN_ALPHALOWERCHAR
#define NUM           ARC_LEXER_TOKEN_NUMBER
#define CHAR_OR_NUM   23
#define VARIABLE_NAME 24
#define VARIABLE      25

void TEST_ParserData_CreateStringFn(void **data){
    ARC_String_Create((ARC_String **)data, NULL, 0);
}

void TEST_ParserData_DestroyStringFn(void *data){
    ARC_String_Destroy((ARC_String *)data);
}

//for this very basic example, the tagId does not matter
void TEST_ParserTag_AddFirstCharFn(void **data, uint32_t tagId, uint32_t tagIndex, ARC_LexerToken *token, void *userData){
    if(*data == NULL){
        return;
    }

    ARC_String *tokenData = NULL;
    ARC_String_Copy(&tokenData, token->data);
    ARC_String_Append(&tokenData, *data);
    ARC_String_Destroy(*data);
    *data = tokenData;
}

//for this very basic example, the tagId does not matter
void TEST_ParserTag_AddCharFn(void **data, uint32_t tagId, uint32_t tagIndex, ARC_LexerToken *token, void *userData){
    if(*data == NULL){
        return;
    }

    ARC_String_Append((ARC_String **)data, token->data);
}

uint32_t *charOrNumTokens[]      = { (uint32_t[]){ 1, CHAR }, (uint32_t[]){ 1, NUM } };
uint32_t *variableNameTags[]     = { (uint32_t[]){ 2, CHAR_OR_NUM, VARIABLE_NAME }, (uint32_t[]){ 1, LAMBDA } };
uint32_t *variableTokensOrTags[] = { (uint32_t[]){ 2, CHAR, VARIABLE_NAME } };

//TODO: note how language function callbacks work, and how they use the parentData if createDataFn is NULL
ARC_ParserData_CreateFn  createStringFn  = TEST_ParserData_CreateStringFn;
ARC_ParserData_DestroyFn destroyStringFn = TEST_ParserData_DestroyStringFn;

ARC_ParserTag_AddDataFn addCharFn      = TEST_ParserTag_AddCharFn;
ARC_ParserTag_AddDataFn addFirstCharFn = TEST_ParserTag_AddFirstCharFn;

ARC_ParserTag testTags[3] = {
    {
        VARIABLE,             //tagId
        variableTokensOrTags, //tokensOrTags
        1,                    //tokenOrTagsSize
        &addFirstCharFn,      //addDataFn
        NULL                  //addUserData
    },
    {
        VARIABLE_NAME,    //tagId
        variableNameTags, //tokensOrTags
        2,                //tokenOrTagsSize
        NULL,             //addDataFn
        NULL              //addUserData
    },
    {
        CHAR_OR_NUM,     //tagId
        charOrNumTokens, //tokensOrTags
        2,               //tokenOrTagsSize
        &addCharFn,      //addDataFn
        NULL             //addUserData
    }
};

ARC_Array languageArray = {
    3,       //size
    testTags //data
};

void TEST_Parser_InitLexerRulesFn(ARC_Lexer *lexer){
    ARC_Lexer_InitBasicTokenRules(lexer);
}

ARC_TEST(Parser_Init){
    ARC_Parser *parser;

    ARC_Parser_Create(&parser, &languageArray, TEST_Parser_InitLexerRulesFn, NULL, NULL);

    ARC_Parser_Destroy(parser);

    ARC_CHECK(arc_errno == 0);
}

ARC_TEST(Parser_Basic_Parse){
    ARC_Parser *parser;

    ARC_Parser_Create(&parser, &languageArray, TEST_Parser_InitLexerRulesFn, NULL, NULL);
    ARC_String *tempString;


    /* ~ first test ~ */
    ARC_String_CreateWithStrlen(&tempString, "myvar1");

    //this destroys string, so no need for cleanup
    ARC_Parser_Parse(parser, &tempString);

    ARC_CHECK(arc_errno == 0);


    /* ~ second test ~ */
    ARC_String_CreateWithStrlen(&tempString, "z1xwvq");
    //this destroys string, so no need for cleanup
    ARC_Parser_Parse(parser, &tempString);


    ARC_CHECK(arc_errno == 0);


    /* ~ third test ~ */
    ARC_String_CreateWithStrlen(&tempString, "z1234");

    //this destroys string, so no need for cleanup
    ARC_Parser_Parse(parser, &tempString);

    ARC_CHECK(arc_errno == 0);


    /* ~ fourth test ~ */
    ARC_String_CreateWithStrlen(&tempString, "aaaaa");

    //this destroys string, so no need for cleanup
    ARC_Parser_Parse(parser, &tempString);

    ARC_CHECK(arc_errno == 0);


    /* ~ cleanup ~ */
    ARC_Parser_Destroy(parser);
}

ARC_TEST(Parser_Basic_ParseError){
    ARC_Parser *parser;

    ARC_Parser_Create(&parser, &languageArray, TEST_Parser_InitLexerRulesFn, NULL, NULL);

    ARC_String *tempString;


    /* ~ first test ~ */
    ARC_String_CreateWithStrlen(&tempString, "!myVar1");

    //this destroys string, so no need for cleanup
    ARC_Parser_Parse(parser, &tempString);

    ARC_CHECK(arc_errno == ARC_ERRNO_DATA);


    /* ~ second test ~ */
    //check again with moved character
    arc_errno = 0;
    ARC_String_CreateWithStrlen(&tempString, "my!Var1");

    //this destroys string, so no need for cleanup
    ARC_Parser_Parse(parser, &tempString);

    ARC_CHECK(arc_errno == ARC_ERRNO_DATA);


    /* ~ third test ~ */
    //check again with moved character
    arc_errno = 0;
    ARC_String_CreateWithStrlen(&tempString, "myVar1!");

    //this destroys string, so no need for cleanup
    ARC_Parser_Parse(parser, &tempString);

    ARC_CHECK(arc_errno == ARC_ERRNO_DATA);


    /* ~ cleanup ~ */
    ARC_Parser_Destroy(parser);

    //reset for next test
    arc_errno = 0;
}

ARC_TEST(Parser_Basic_GetParsedValue){
    ARC_Parser *parser;

    ARC_Parser_Create(&parser, &languageArray, TEST_Parser_InitLexerRulesFn, &createStringFn, &destroyStringFn);

    ARC_String *tempString;


    /* ~ first test ~ */
    ARC_String_CreateWithStrlen(&tempString, "myvar1");

    //this destroys string, so no need for cleanup
    ARC_Parser_Parse(parser, &tempString);

    ARC_CHECK(arc_errno == 0);

    ARC_String *checkValue = (ARC_String *)ARC_Parser_GetData(parser);
    ARC_CHECK(ARC_String_EqualsCStringWithStrlen(checkValue, "myvar1"));


    /* ~ cleanup ~ */
    ARC_Parser_Destroy(parser);
}

ARC_TEST(Parser_ParserLang_BasicTest){
    ARC_Parser *parser;
    ARC_Parser_CreateAsParserLang(&parser);

    ARC_String *tempString;
    ARC_String_CreateWithStrlen(&tempString, "<test> -> <testingStuffs>\n");

    //this destroys string, so no need for cleanup
    ARC_Parser_Parse(parser, &tempString);

    ARC_Parser_Destroy(parser);

    ARC_CHECK(arc_errno == 0);
}

ARC_TEST(Parser_ParserLang_BasicVector){
    ARC_Vector *testLanguage;
    ARC_Vector_Create(&testLanguage, NULL, NULL);

    ARC_Vector_Add(testLanguage, testTags + 0);
    ARC_Vector_Add(testLanguage, testTags + 1);
    ARC_Vector_Add(testLanguage, testTags + 2);

    ARC_Parser *parser;
    ARC_Parser_CreateFromVector(&parser, testLanguage, TEST_Parser_InitLexerRulesFn, NULL, NULL);

    ARC_String *tempString;
    ARC_String_CreateWithStrlen(&tempString, "variablename");

    //this destroys string, so no need for cleanup
    ARC_Parser_Parse(parser, &tempString);

    //cleanup
    ARC_Parser_Destroy(parser);
    ARC_Vector_Destroy(testLanguage);

    ARC_CHECK(arc_errno == 0);
}