#include <stdio.h>
#include <stdlib.h>
#include "../vars/vars.c"

//hashmaps/link list heads
extern map_void_t *_var_map;
extern node_info *_temp_statement_head;
//struct variable *_var_head = NULL; 
extern map_void_t *_function_list;

node_info* create_var_assignment_string(char *pName, char *pString) {
    
    node_info *newNode = malloc(sizeof(node_info));
    variable *newVar = make_variable_string(pName, pString);
    newNode->type = ASSIGNMENT;
    newNode->opperation = 1;
    newNode->var = newVar;
    return newNode;
    
}

node_info* create_var_assignment_int(char *pName, int number) {
    
    node_info *newNode = malloc(sizeof(node_info));
    variable *newVar = make_variable_int(pName, number);
    newNode->type = ASSIGNMENT;
    newNode->opperation = 1;
    newNode->var = newVar;
    return newNode;
    
}

node_info* create_var_assignment_char(char *pName, char Char) {
    
    node_info *newNode = malloc(sizeof(node_info));
    variable *newVar = make_variable_char(pName, Char);
    newNode->type = ASSIGNMENT;
    newNode->opperation = 1;
    newNode->var = newVar;
    return newNode;
    
}

node_info* create_var_assignment_double(char *pName, double Double) {
    
    node_info *newNode = malloc(sizeof(node_info));
    variable *newVar = make_variable_double(pName, Double);

    //new node stuff
    newNode->type = ASSIGNMENT;
    newNode->opperation = 1;
    newNode->var = newVar;
    return newNode;
    
}


/*
Adds statement to linked list.

@param nodeInfo link to be added.
@return head of linked list.
*/
node_info* add_to_compound_statement(node_info *new_statement, node_info *statement_head) {
    
    if(statement_head == NULL) {
        
        statement_head = malloc(sizeof(node_info));
        statement_head->opperation = 5;
        statement_head->next = new_statement;
        statement_head->next->next = NULL;
        statement_head->statement_list = NULL;
        
    } else {
        
        node_info *p = statement_head; //make a temp of list head, so we can traverse it.
        
        //TODO replace with double linked list end
        while (p->statement_list != NULL) {
            
            p = p->statement_list;
            
        }
        //TODO replace with double linked list end
        while (p->next != NULL) {
            
            p = p->next;
            
        }
        
        p->next = malloc(sizeof(node_info));
        p->next = new_statement;
        p->next->next = NULL;
        
    }
    return statement_head;
    
}

/*
Executes a statment.

@param nodeInfo statement to be executed
@return void.
*/

//TODO return bool or int detailing the status of execution.
void ex(node_info *n) {
    
    switch(n->opperation){
        
        case 1:
            add_var(n->var->name, n->var->value, _var_map);
            break;
        //TODO expression stuff
        case 2:
        
            break;
        
        //print
        case 3:
            
            switch(n->printExpression.opperation) {
                
                case 1:
                    printf("%d\n", (int) n->printExpression.value);
                    break;
                case 2:
                    printf("%s\n", n->printExpression.string);
                    break;
                    
                case 3:
                    printf("%s%lf\n", n->printExpression.string, n->printExpression.value);
                    break;
                    
                default:
                    printf("{ERROR} CHECK YACC FILE FOR INCORRECT PRINT\n");
                    
            }
            
            break;
        //logic (if, while, for, etc)
        case 4:
        
            switch(n->logicalExpression.opperation) {
                case 1:
                
                    if (n->logicalExpression.expr == 1) {
                        
                        ex(n->logicalExpression.if_true);
                        
                    }
                    break;
                    
                case 2:
                
                    while (n->logicalExpression.expr == 1) {
                        
                        ex(n->logicalExpression.while_true);
                        
                    }
                    break;
                    
                default:
                
                    printf("{ERROR} SOMETHING WRONG WITH LOGICAL EXPRESSION CHECK YACC\n");
                    exit(1);
                    
            }
            break;
            
        case 5:
            while(n->next != NULL) {
                
                n = n->next;
                ex(n);
                
            }
            break;
            
        case 6:
            ;
            variable_values *value = get_value(n->name, _var_map);
            
            switch(value->type) {
                
                case VAR_STRING:
                    
                    printf("%s\n", value->_string);
                    
                    break;
                    
                case VAR_INT:
                
                    printf("%d\n", value->_int);
                    break;
                    
                case VAR_CHAR:
                    
                    printf("%c\n", value->_char);
                    break;
                    
                
                case VAR_DOUBLE:
                
                    printf("%f\n", value->_double);
                    break;
                    
                case VAR_VOID: //TODO add void variable type
                    break;
                
                default:
                
                    printf("{ERROR} NO SUCH VARIABLE TYPE CHECK YACC!\n");
                    exit(1);
                
            }
            
            break;
        
        //TODO update default to case 7 for functions
        default:
            ;
            
            switch(n->type) {
                
                case FUNCTION_CALL:
                    ;
                    //gets the statements of a function with the provided name
                    node_info *_stmts = *map_get(&*((map_void_t* ) _function_list), n->name);
                    while (_stmts->next != NULL) { //loop over all the statements and execute them
                        _stmts = _stmts->next;
                        ex(_stmts);
                    }
                    break;
                    
                case FUNCTION:
                    ;
                    //if the list of functions already defined is null then we malloc space for it.
                    if (_function_list == NULL) {
                        
                        _function_list = malloc(sizeof(map_void_t));
                        n->_var_list = malloc(sizeof(node_info));
                        
                        n->next = NULL;
                        n->local_list = NULL;
                        map_init(&*((map_void_t *) _function_list));
                        map_init(&*((map_void_t *) n->_var_list));
                        //put the function in the hashmap
                        map_set(&*((map_void_t* ) _function_list), n->name, &*n->_function_body);
                    } else { //else we dont malloc, we just put the function inside of the hashmap.
                    
                        map_set(&*((map_void_t* ) _function_list), n->name, &*n->_function_body);
                        
                    }
                    break;
                    
                default:
                    ;
                    //TODO add error here and close
            }
            
    }
    
}