/* See COPYING.txt for the full license governing this code. */
/**
 * \file parsehelper.c
 *
 * Source file with some helper functions for parsing strings.
 */

#include <SDL_test.h>
#include "SDL_visualtest_harness_argparser.h"

/* this function uses a DFA to count the number of tokens in an agruments string.
   state 0 is taken to be the start and end state. State 1 handles a double quoted
   argument and state 2 handles unquoted arguments. */
static int
CountTokens(char* args)
{
    int index, num_tokens;
    int state; /* current state of the DFA */

    if(!args)
    	return -1;

    index = 0;
    state = 0;
    num_tokens = 0;
    while(args[index])
    {
        char ch = args[index];
        switch(state)
        {
            case 0:
            if(ch == '\"')
            {
                state = 1;
                num_tokens++;
            }
            else if(!SDL_isspace(ch))
            {
                state = 2;
                num_tokens++;
            }
            break;

            case 1:
            if(ch == '\"')
            {
                state = 0;
            }
            break;

            case 2:
            if(SDL_isspace(ch))
            {
                state = 0;
            }
            break;
        }
        index++;
    }
    return num_tokens;
}

/* - size of tokens is num_tokens + 1
- uses the same DFA used in CountTokens() to split args into an array of strings */
static int
TokenizeHelper(char* str, char** tokens, int num_tokens, int max_token_len)
{
    int index, state, done, st_index, token_index;

    if(!str)
    {
        SDLTest_LogError("str argument cannot be NULL");
        return 0;
    }
    if(!tokens)
    {
        SDLTest_LogError("tokens argument cannot be NULL");
        return 0;
    }
    if(num_tokens <= 0)
    {
        SDLTest_LogError("num_tokens argument must be positive");
        return 0;
    }
    if(max_token_len <= 0)
    {
        SDLTest_LogError("max_token_len argument must be positive");
        return 0;
    }

    /* allocate memory for the tokens */
    tokens[num_tokens] = NULL;
    for(index = 0; index < num_tokens; index++)
    {
        tokens[index] = (char*)SDL_malloc(max_token_len);
        if(!tokens[index])
        {
            int i;
            SDLTest_LogError("malloc() failed.");
            for(i = 0; i < index; i++)
                SDL_free(tokens[i]);
            return 0;
        }
        tokens[index][0] = '\0';
    }

    /* copy the tokens into the array */
    st_index = 0;
    index = 0;
    token_index = 0;
    state = 0;
    done = 0;
    while(!done)
    {
        char ch = str[index];
        switch(state)
        {
            case 0:
            if(ch == '\"')
            {
                state = 1;
                st_index = index + 1;
            }
            else if(!ch)
                done = 1;
            else if(ch && !SDL_isspace(ch))
            {
                state = 2;
                st_index = index;
            }
            break;

            case 1:
            if(ch == '\"')
            {
                int i;
                state = 0;
                for(i = st_index; i < index; i++)
                {
                    tokens[token_index][i - st_index] = str[i];
                }
                tokens[token_index][i - st_index] = '\0';
                token_index++;
            }
            else if(!ch)
            {
                SDLTest_LogError("Parsing Error!");
                done = 1;
            }
            break;

            case 2:
            if(!ch)
                done = 1;
            if(SDL_isspace(ch) || !ch)
            {
                int i;
                state = 0;
                for(i = st_index; i < index; i++)
                {
                    tokens[token_index][i - st_index] = str[i];
                }
                tokens[token_index][i - st_index] = '\0';
                token_index++;
            }
            break;
        }
        index++;
    }
    return 1;
}

char**
SDLVisualTest_Tokenize(char* str, int max_token_len)
{
    int num_tokens;
    char** tokens;

    if(!str)
    {
        SDLTest_LogError("str argument cannot be NULL");
        return NULL;
    }
    if(max_token_len <= 0)
    {
        SDLTest_LogError("max_token_len argument must be positive");
        return NULL;
    }

    num_tokens = CountTokens(str);
    if(num_tokens == 0)
        return NULL;

    tokens = (char**)SDL_malloc(sizeof(char*) * (num_tokens + 1));
    if(!TokenizeHelper(str, tokens, num_tokens, max_token_len))
    {
        SDLTest_LogError("TokenizeHelper() failed");
        SDL_free(tokens);
        return NULL;
    }
    return tokens;
}

char**
SDLVisualTest_ParseArgsToArgv(char* args)
{
    char** argv;
    int num_tokens;

    num_tokens = CountTokens(args);
    if(num_tokens == 0)
        return NULL;

    /* allocate space for arguments */
    argv = (char**)SDL_malloc((num_tokens + 2) * sizeof(char*));
    if(!argv)
    {
        SDLTest_LogError("malloc() failed.");
        return NULL;
    }

    /* tokenize */
    if(!TokenizeHelper(args, argv + 1, num_tokens, MAX_SUT_ARGS_LEN))
    {
        SDLTest_LogError("TokenizeHelper() failed");
        SDL_free(argv);
        return NULL;
    }
    argv[0] = NULL;
    return argv;
}