#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;

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

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

    if (length == 0) return NULL;

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

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

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);
        free(list->tokens[i]);
    }

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

int AddTokenToList(TokenType type, char* lexeme, 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;

    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() {
    char c = Advance();

    switch (c) {
    case '(':
    case ')':
    case '{':
    case '}':
    case ',':
    case '.':
    case '-':
    case '+':
    case ';':
    case '*':
    break;
    }
}

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

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