#include "compiler.h"
#include <stdlib.h>

size_t common_string_hash_djb2(const unsigned char* value, size_t length)
{
    size_t hash = 5381;
    for (size_t i = 0; i < length && value[i] != '\0'; ++i)
        hash = ((hash << 5) + hash) + value[i];
    return hash;
}

int string_symbol_map_construct(StringSymbolMap* map)
{
    const size_t start_capacity = 4;
    *map = (StringSymbolMap) {
        .data = malloc(sizeof(StringSymbolMap) * start_capacity),
        .length = 0,
        .capacity = start_capacity,
    };
    if (map->data == NULL) {
        return -1;
    }
    return 0;
}

void string_symbol_map_destroy(StringSymbolMap* map)
{
    if (map->data != NULL) {
        free(map->data);
    }
}

Symbol* string_symbol_map_get(const StringSymbolMap* map, size_t key_hash)
{
    for (size_t i = 0; i < map->length; ++i) {
        if (map->data[i].key_hash == key_hash) {
            return &map->data[i].value;
        }
    }
    return NULL;
}

int string_symbol_map_set(StringSymbolMap* map, size_t key_hash, Symbol value)
{
    Symbol* existing = string_symbol_map_get(map, key_hash);
    if (existing != NULL) {
        *existing = value;
        return 0;
    }
    if (map->length + 1 >= map->capacity) {
        map->capacity *= 2;
        StringSymbolMapEntry* data
            = realloc(map->data, sizeof(StringSymbolMapEntry) * map->capacity);
        if (data == NULL) {
            return -1;
        }
        map->data = data;
    }
    map->data[map->length] = (StringSymbolMapEntry) { key_hash, value };
    map->length += 1;
    return 0;
}

int statements_symbols_vec_construct(StatementsSymbolsVec* vec)
{
    const size_t start_capacity = 4;
    StatementsSymbols* data
        = malloc(start_capacity * sizeof(StatementsSymbols));
    if (data == NULL) {
        return -1;
    }
    *vec = (StatementsSymbolsVec) {
        .data = data,
        .length = 0,
        .capacity = start_capacity,
    };
    return 0;
}

void statements_symbols_vec_destroy(StatementsSymbolsVec* vec)
{
    if (vec->data != NULL) {
        free(vec->data);
    }
}

int statements_symbols_vec_push(
    StatementsSymbolsVec* vec, StatementsSymbols pair)
{
    if (vec->length + 1 > vec->capacity) {
        StatementsSymbols* new_data
            = realloc(vec->data, vec->capacity * 2 * sizeof(StatementsSymbols));
        if (new_data == NULL) {
            return -1;
        }
        vec->capacity *= 2;
        vec->data = new_data;
    }
    vec->data[vec->length] = pair;
    vec->length += 1;
    return 0;
}

void symbol_table_construct(SymbolTable* table, SymbolTable* parent)
{
    *table = (SymbolTable) {
        .parent = parent,
        .map = { 0 },
    };
    string_symbol_map_construct(&table->map);
}

void symbol_table_destroy(SymbolTable* table)
{
    string_symbol_map_destroy(&table->map);
}

void checker_construct(Checker* checker)
{
    *checker = (Checker) {
        .failed = false,
        .statements_symbols = { 0 },
    };
    statements_symbols_vec_construct(&checker->statements_symbols);
}

void checker_destroy(Checker* checker) { (void)checker; }

bool checker_failed(const Checker* checker) { return checker->failed; }

CheckerResult checker_result(Checker* checker)
{
    return (CheckerResult) {
        .head_table = checker->head_table,
        .statements_symbols = checker->statements_symbols,
    };
}

void checker_check_statements(Checker* checker, ASTNode* node)
{
    SymbolTable table;
    symbol_table_construct(&table, &checker->head_table);
    for (size_t i = 0; i < node->statements.length; ++i) {
        checker_check_statement(checker, &table, node->statements.data[i]);
    }
    statements_symbols_vec_push(&checker->statements_symbols,
        (StatementsSymbols) {
            .table = table,
            .statements = node,
        });
}

void checker_check_statement(
    Checker* checker, SymbolTable* table, ASTNode* node)
{
    switch (node->node_type) {
        case ASTNodeType_Block:
            checker_check_statements(checker, node);
        case ASTNodeType_If:
        case ASTNodeType_Loop:
        case ASTNodeType_Assign:
        case ASTNodeType_Let:
        case ASTNodeType_Break:
        case ASTNodeType_Fn:
        case ASTNodeType_Return:
            break;
        default:
            break;
    }
}