#include "scanner.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

const char* source_code;
//Start and Current hold the offsets that index into the string source_code.
int start;   //Points to the first character in the lexeme being scanned.
int current; //points to the character currently being considered.
int length;
int line = 1;

const char* Advance(void);
int IsAtend(void);
void ScanToken(TokenList*);
TokenList* CreateList(void);

TokenList* ScanTokens(const char* source) {
    if (!source) return NULL;
    
    source_code = source;
    length = strlen(source);

    if (length == 0) return NULL;

    TokenList* tokens = CreateList();

    while(!IsAtend()) {
        start = current;
        ScanToken(tokens);
    }

    //Add EOF token and return list once that's set up.
    return tokens;
}

TokenList* CreateList() {
    TokenList* list = calloc(1, sizeof(TokenList));

    if (!list) {
        fprintf(stderr, "Failed to calloc TokenList.\n");
        return NULL;
    }

    list->tokens = calloc(DEFAULT_TOKENLIST_SIZE, sizeof(Token*));

    if (!list->tokens) {
        free(list);
        fprintf(stderr, "Failed to calloc tokens.\n");
        return NULL;
    }

    list->capacity = DEFAULT_TOKENLIST_SIZE;
    list->size = 0;

    return list;
}

void DestroyTokenList(TokenList* list) {
    if (!list) return;

    for(int i = 0; i < list->size; i++) {
        //free(list->tokens[i]->lexeme); This shouldn't be needed since the lexeme is a pointer into the source code.
        free(list->tokens[i]);
    }

    free(list->tokens);
    free(list);
}

int AddTokenToList(TokenType type, const char* lexeme, int length, TokenList* tokens) {
    if (!tokens) return 0;
    Token* token = calloc(1, sizeof(Token));

    if (!token) {
        fprintf(stderr, "Failed to calloc memory for new Token.\n");
        return 0;
    }

    token->lexeme = lexeme;
    token->type = type;
    token->length = length; //Set the length of the lexeme (which is just a pointer into the complete soure listing).

    if ((tokens->size + 1) > tokens->capacity) {
        void* new_ptr = realloc(tokens->tokens, sizeof(Token*) * tokens->capacity * 2);//calloc(tokens->capacity * 2, sizeof(Token*));

        if (!new_ptr) {
            fprintf(stderr, "Failed to realloc TokenList to size %d.\n", tokens->capacity * 2);
            return 0;
        }

        tokens->tokens = new_ptr;
        tokens->capacity = tokens->capacity * 2;
    }

    tokens->tokens[tokens->size] = token;
    tokens->size++;

    return 1;
}

void ScanToken(TokenList* tokens) {
    const char* c = Advance();

    switch (*c) {
    case '(':
        AddTokenToList(LParen, c, 1, tokens);
        break;
    case ')':
        AddTokenToList(RParen, c, 1, tokens);
        break;
    case '{':
        AddTokenToList(LBrace, c, 1, tokens);
        break;
    case '}':
        AddTokenToList(RBrace, c, 1, tokens);
        break;
    case ',':
        AddTokenToList(Comma, c, 1, tokens);
        break;
    case '.':
        AddTokenToList(Dot, c, 1, tokens);
        break;
    case '-':
        AddTokenToList(Minus, c, 1, tokens);
        break;
    case '+':
        AddTokenToList(Plus, c, 1, tokens);
        break;
    case ';':
        AddTokenToList(Semicolon, c, 1, tokens);
        break;
    case '*':
        AddTokenToList(Star, c, 1, tokens);
        break;
    }
}

int IsAtend() {
    return current >= length;
}

const char* Advance() {
    return &source_code[current++];
}