#include <vslc.h>




// Externally visible, for the generator
extern tlhash_t *global_names;
extern char **string_list;
extern size_t n_string_list, stringc;

// Implementation choices, only relevant internally
static void find_globals ( void );
/** @param function Function's symbol table entry
 *  @param root Function's root node */
static void bind_names ( symbol_t *function, node_t *root );

/* Helper functions */
void print_global_tree(symbol_t* global);
void insert_symbol(tlhash_t *hash_table, symbol_t* symbol);
void push_scope(void);
void pop_scope(void);

static uint64_t no_scopes, cur_scope_depth;
static tlhash_t **scopes;

void
create_symbol_table ( void )
{

    // Initialize string array
    string_list = malloc(n_string_list * sizeof(char*));
    n_string_list = DEFAULT_STRING_LIST_SIZE;
    stringc = 0;

    no_scopes = DEFAULT_NO_SCOPES;
    cur_scope_depth = 0;
    scopes = malloc(no_scopes * sizeof(tlhash_t));

    find_globals();
    /* TODO: traverse the syntax tree and create the symbol table */

/*
    // ! Example code solely to demonstrate usage of tlhash. Make sure to remove
    // ! or comment this out when implementing your solution.

    // Initialize table
    tlhash_t *my_table = (tlhash_t*)malloc(sizeof(tlhash_t));
    tlhash_init(my_table, 64);

    char *my_key0 = "key";    // Keep in mind that these are stack allocated for simplicity, yours should not
    char *my_val0 = "valuable"; // Also, I'm using strings as values, you will be using symbol_t pointers
    char *my_key1 = "another_key";
    char *my_val1 = "more valuable";
    
    // Insert some values to the table. Remember that the length of a string
    // interpreted as an array is the string length plus one '\0' character
    tlhash_insert(my_table, my_key0, strlen(my_key0)+1, my_val0);
    tlhash_insert(my_table, my_key1, strlen(my_key1)+1, my_val1);

    // Iterate keys and lookup their values
    size_t size = tlhash_size(my_table);
    char **keys = (char **)malloc(size);
    tlhash_keys(my_table, keys);
    char *val;
    for (int i = 0; i < size; i++) {
        tlhash_lookup(my_table, keys[i], strlen(keys[i])+1, &val);
        printf("my_table[%s] = \"%s\"\n", keys[i], val);
    }

    // Free allocated memory when done with the symbol table
    tlhash_finalize(my_table);
    free(my_table);
    free(keys);
*/
}


const char *symbol_names[4] = {"GLOBAL_VAR", "FUNCTION", "PARAMETER", "LOCAL_VAR"};
void 
print_global_tree(symbol_t* global)
{
    if (!global)
        return;
    
    printf("─%s(%s, %ld)\n", symbol_names[global->type], global->name, global->seq);
    
    if (!global->nparms && !global->locals)
        return;
    
    uint64_t no_locals = tlhash_size(global->locals);
    symbol_t **locals_list = malloc(no_locals * sizeof(symbol_t));
    tlhash_values(global->locals, (void **)locals_list );
    for (int l = 0; l < no_locals; l++)
    {
        printf(" %s─%s(%s, %ld)\n", 
            (l < (global->nparms - 1)) ? "├" : "└", 
            symbol_names[locals_list[l]->type],
            locals_list[l]->name,
            locals_list[l]->seq
        );
    }
    //putchar('\n');
    free(locals_list);
}


void
print_symbol_table ( void )
{
    /* TODO: output its contents */
    /* Get the number of symbols, size up a temporary list and fill it */
    uint64_t no_globals = tlhash_size(global_names);
    symbol_t **global_list = malloc(no_globals * sizeof(symbol_t));
    tlhash_values(global_names, (void **)global_list );

    /* Iterate over the temporary list, printing entries */
    for (uint64_t g = 0; g < no_globals; g++ )
    {
        //printf("global: %s\n", global_list[g]->name );
        print_global_tree(global_list[g]);
    }
    free(global_list);
}

void 
destroy_global(symbol_t* global)
{
    if (!global)
        return;
    if (!global->locals)
    {
        free(global);
        return;
    }
    
    uint64_t no_locals = tlhash_size(global->locals);
    symbol_t **locals_list = malloc(no_locals * sizeof(symbol_t));
    tlhash_values(global->locals, (void **)locals_list );

    for (int l = 0; l < no_locals; l++)
        free(locals_list[l]);
    
    tlhash_finalize(global->locals);
    free(global->locals);
    free(global);

    free(locals_list);
}

void
destroy_symbol_table ( void )
{
    //return;
    /* TODO: release memory allocated to the symbol table */
    for (uint64_t c = 0; c < stringc; c++)
        free(string_list[c]);
    free(string_list);

    if (!global_names)
        return;

    uint64_t no_globals = tlhash_size(global_names);
    symbol_t **global_list = malloc(no_globals * sizeof(symbol_t));
    tlhash_values(global_names, (void **)global_list );

    for (uint64_t g = 0; g < no_globals; g++)
        destroy_global(global_list[g]);
    
    tlhash_finalize(global_names);
    free(global_names);

    free(global_list);
}

void 
insert_symbol(tlhash_t *hash_table, symbol_t* symbol)
{
    tlhash_insert(hash_table, symbol->name, strlen(symbol->name), symbol);
}

void
find_globals ( void )
{
    tlhash_init(global_names = malloc(sizeof(tlhash_t)), GLOBAL_BUCKET_SIZE);
    /* TODO: Populate symbol table with global variables and functions */

    uint64_t no_functions = 0;
    node_t *global_list = root;

    // Check if not nullptr
    if (!global_list)
        return;

    symbol_t* global_symbol;
    for (uint64_t global_i = 0; global_i < global_list->n_children; global_i++)
    {
        node_t *current_global = global_list->children[global_i];
        switch (current_global->type)
        {
        case VARIABLE_LIST:

            // Go through the variable list and get all the global variables
            for (uint64_t var_i = 0; var_i < current_global->n_children; var_i++)
            {
                global_symbol = malloc(sizeof(symbol_t));
                *global_symbol = (symbol_t){
                    .type   = SYM_GLOBAL_VAR,
                    .name   = current_global->children[var_i]->data,
                    .node   = current_global->children[var_i],
                    .seq    = 0,
                    .nparms = 0,
                    .locals = NULL
                };
                insert_symbol(global_names, global_symbol);
            }
            break;
        case FUNCTION:
            node_t *function = current_global;

            // Function node allways have the same structure,
            // [0] are the identifier
            // [1] are the variable list, within a paramerer_list
            if (!function->children[0])
                break;

            // Create the function symbol
            global_symbol = malloc(sizeof(symbol_t));
            *global_symbol = (symbol_t){
                .type   = SYM_FUNCTION,
                .name   = current_global->children[0]->data,
                .node   = current_global->children[0],
                .seq    = no_functions++,
                .nparms = 0,
                .locals = malloc(sizeof(tlhash_t))
            };

            // Initialize the local variable table
            tlhash_init(global_symbol->locals, LOCAL_BUCKET_SIZE);

            // Insert the pointer to the newly created symbol
            insert_symbol(global_names, global_symbol);

            // If there are no parameters in function, break.
            if (!current_global->children[1]->n_children)
                break;


            // Find all params and insert into hash table in global_symbol
            symbol_t *param_sym;
            node_t *param_list = current_global->children[1]->children[0];
            global_symbol->nparms = param_list->n_children;

            for (uint64_t param_i = 0; param_i < param_list->n_children; param_i++)
            {
                param_sym = malloc(sizeof(symbol_t));
                *param_sym = (symbol_t){
                    .type   = SYM_PARAMETER,
                    .name   = param_list->children[param_i]->data,
                    .node   = param_list->children[param_i],
                    .seq    = param_i,
                    .nparms = 0,
                    .locals = NULL
                };

                insert_symbol(global_symbol->locals, param_sym);
            }
            break;
        }
    }
    
}

void
push_scope(void)
{
    scopes[cur_scope_depth] = malloc(sizeof(tlhash_t));
    tlhash_init(scopes[cur_scope_depth++], LOCAL_BUCKET_SIZE);

    if (cur_scope_depth >= no_scopes)
    {
        no_scopes *= 2;
        tlhash_t **new_scopes = realloc(scopes, no_scopes * sizeof(tlhash_t));
        if (!new_scopes)
        {
            fprintf(stderr, "[ERROR] Could not realloc scopes!\n");
            exit(EXIT_FAILURE);
        }
        scopes = new_scopes;
    }
}

void
pop_scope(void)
{
    tlhash_finalize(scopes[--cur_scope_depth]);
    free(scopes[cur_scope_depth]);
    //scopes[cur_scope_depth] = NULL;
}


void 
bind_names ( symbol_t *function, node_t *root )
{
    /* TODO: Bind names and string literals in local symbol table */
    if (!function)
        return;
    if (!root)
        return;
    
    // We want do top to bottom traverse, so do not 
    // call recusivly unless we need to go deeper
    switch (root->type)
    {
    case BLOCK:
        push_scope();
        for (uint64_t i = 0; i < root->n_children; i++)
            bind_names(function, root->children[i]);
        pop_scope();
    case DECLARATION_LIST:

        /* code */
        break;
    
    case IDENTIFIER_DATA:

        break;

    case STRING_DATA:
        break;
    
    default:
        for (uint64_t i = 0; i < root->n_children; i++)
            bind_names(function, root->children[i]);
        break;
    }
}