#include "tokens.h"
#include <stdlib.h>
#include <string.h>

#ifdef STANDALONE
#include <stdio.h>
#undef printd
#define printd(...) fprintf(stderr, __VA_ARGS__)
#else
#include <pebble.h>
#undef printd
#undef printf
#define printf(...) APP_LOG(APP_LOG_LEVEL_DEBUG, __VA_ARGS__)
#define printd(...) printf(__VA_ARGS__)
#endif

#define ERR_LEN 256

/*
 * Grammar:
 * token
 * expr
 * (op expr expr)
 * (list expr expr ... )
 */

// Is the char a standalone token?
static const char singleTokens[] = "()+-*/=";
int isSingle(const char c) {
    int i = 0;
    while(singleTokens[i] != '\0'){
        if(singleTokens[i] == c)
            return singleTokens[i];
        i++;
    }
    return 0;
}

int isDigit(const char c) {
    return c >= '0' && c <= '9';
}

int isHex(const char c) {
    return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f');
}

int isWhitespace(const char c) {
    return c == ' ' || c == '\t' || c == '\n';
}

int notWhitespace(const char c) {
    return !isWhitespace(c);
}

// Return needs to be freed, if not null
struct Slice *nf_tokenize(const char *input, char **err)
{
    if(!input) {
        *err = malloc(sizeof(char) * ERR_LEN);
        strcpy(*err, "no input");
        return NULL;
    }

    int token_count = MAX_TOK_CNT;
    struct Slice *slices = malloc(sizeof(struct Slice) * token_count);
    while(slices == NULL) {
        token_count /= 2;
        slices = malloc(sizeof(struct Slice) * token_count);
    }

    int i = 0;
    int slice = 0;

    int parens = 0;
    while(input[i] != '\0') {
        int l = 1;
        // printd("input: '%c'\n", input[i]);

        if(isWhitespace(input[i]) || input[i] == ';') {
            i++;
            continue;
        }

        if(input[i] == '(') {
            parens++;
        } else if (input[i] == ')') {
            parens--;
            if(parens < 0) {
                *err = malloc(sizeof(char) * ERR_LEN);
                int start = i > ERR_LEN ? i - ERR_LEN : 0;
                strncpy(*err, &input[start], ERR_LEN);
                free(slices);
                return NULL;
            }
        }

        slices[slice].text = &input[i];

        if(isSingle(input[i])) {
            i++;
        } else if(input[i] == '"' || input[i] == '\'') {
            const char quote = input[i];
            while(input[++i] != quote && input[i] != '\0') {
                l++;
            }
            i++;
        } else {
            while(!isWhitespace(input[++i]) && !isSingle(input[i]) && input[i] != '\0') {
                l++;
            }
        }

        slices[slice].length = l;
        slice++;
    }

    if(parens != 0){
        *err = malloc(sizeof(char) * ERR_LEN);
        int start = i > ERR_LEN ? i - ERR_LEN : 0;
        strncpy(*err, &input[start], ERR_LEN);
        free(slices);
        return NULL;
    }

    slices[slice].text = NULL;
    slices[slice].length = 0;

    *err = NULL;
    return slices;
}