#include "../include/ast.h"
#include "../include/parser.h"
#include "../include/std/log.h"
#include "../include/std/hash.h"
#include <assert.h>

#define throw(result) do { longjmp(context->env, (result)); } while(0)
#define throw_if_error(result) \
do { \
    int return_if_result; \
    return_if_result = (result); \
    if((return_if_result) != 0) \
        throw(return_if_result); \
} while(0)

static void ast_resolve(Ast *self, AstCompilerContext *context);

Ast ast_none() {
    Ast ast;
    ast.value.func_decl = NULL;
    ast.type = AST_NONE;
    ast.resolve_status = AST_NOT_RESOLVED;
    return ast;
}

void ast_init(Ast *self, void *value, AstType type) {
    self->value.data = value;
    self->type = type;
    self->resolve_status = AST_NOT_RESOLVED;
}

BufferView ast_get_name(Ast *self) {
    BufferView name;
    switch(self->type) {
        case AST_NONE:
        case AST_FUNCTION_DECL:
        case AST_IMPORT:
        case AST_STRING:
        case AST_NUMBER:
        case AST_BINOP:
            name = create_buffer_view_null();
            break;
        case AST_LHS:
            name = self->value.lhs_expr->var_name;
            break;
        case AST_FUNCTION_CALL:
            name = self->value.func_call->name;
            break;
        case AST_VARIABLE:
            name = self->value.variable->name;
            break;
    }
    return name;
}

int funcdecl_init(FunctionDecl *self, ScopedAllocator *allocator) {
    return scope_init(&self->body, allocator);
}

int funccall_init(FunctionCall *self, BufferView name, ScopedAllocator *allocator) {
    self->name = name;
    return buffer_init(&self->args, allocator);
}

void lhsexpr_init(LhsExpr *self, int isConst, BufferView var_name) {
    self->is_const = isConst;
    self->type_name = create_buffer_view_null();
    self->var_name = var_name;
    self->rhs_expr = ast_none();
}

void import_init(Import *self, BufferView path) {
    self->path = path;
}

int string_init(String *self, BufferView str) {
    /* TODO: Convert special characters. For example \n should be converted to binary newline etc */
    self->str = str;
    return 0;
}

void number_init(Number *self, i64 value, bool is_integer) {
    self->value.integer = value;
    self->is_integer = is_integer;
}

void variable_init(Variable *self, BufferView name) {
    self->name = name;
    self->resolved_variable = ast_none();
}

void binop_init(Binop *self) {
    self->lhs = ast_none();
    self->rhs = ast_none();
    self->type = BINOP_ADD;
    self->grouped = bool_false;
}

int scope_init(Scope *self, ScopedAllocator *allocator) {
    return_if_error(buffer_init(&self->ast_objects, allocator));
    return_if_error(hash_map_init(&self->named_objects, allocator, sizeof(Ast), hash_compare_string, amal_hash_string));
    return 0;
}

int scope_add_child(Scope *self, Ast *child) {
    BufferView child_name;
    Ast existing_child;
    bool child_already_exists;

    child_name = ast_get_name(child);
    if(child_name.data) {
        child_already_exists = hash_map_get(&self->named_objects, child_name, &existing_child);
        if(child_already_exists)
            return AST_ERR_DEF_DUP;

        cleanup_if_error(hash_map_insert(&self->named_objects, child_name, child));
    }
    cleanup_if_error(buffer_append(&self->ast_objects, child, sizeof(Ast)));
    return 0;

    cleanup:
    return AST_ERR;
}

void scope_resolve(Scope *self, AstCompilerContext *context) {
    Ast *ast;
    Ast *ast_end;
    ast = buffer_start(&self->ast_objects);
    ast_end = buffer_end(&self->ast_objects);
    for(; ast != ast_end; ++ast) {
        ast_resolve(ast, context);
    }
}

static void lhs_resolve(LhsExpr *self, AstCompilerContext *context) {
    /* TODO: Implement */
    amal_log_debug("Lhs resolve %s name: %.*s, type: %.*s", 
        self->is_const ? "const" : "var",
        self->var_name.size, self->var_name.data,
        self->type_name.size, self->type_name.data);
    ast_resolve(&self->rhs_expr, context);
}

static void funcdecl_resolve(FunctionDecl *self, AstCompilerContext *context) {
    /* TODO: Implement */
    amal_log_debug("funcdecl resolve");
    scope_resolve(&self->body, context);
}

static void funccall_resolve(FunctionCall *self, AstCompilerContext *context) {
    /* TODO: Implement */
    Ast *ast;
    Ast *ast_end;
    ast = buffer_start(&self->args);
    ast_end = buffer_end(&self->args);
    amal_log_debug("funccall resolve, func name: %.*s", self->name.size, self->name.data);
    for(; ast != ast_end; ++ast) {
        ast_resolve(ast, context);
    }
}

static void variable_resolve(Variable *self, AstCompilerContext *context) {
    /* TODO: Implement */
    amal_log_debug("variable resolve, var name: %.*s", self->name.size, self->name.data);
    (void)context;
}

static void binop_resolve(Binop *self, AstCompilerContext *context) {
    /* TODO: Implement */
    ast_resolve(&self->lhs, context);
    ast_resolve(&self->rhs, context);
}
/*
static BufferView ast_get_code_reference(Ast *self) {
    return ast_get_name(self);
}
*/

void ast_resolve(Ast *self, AstCompilerContext *context) {
    /* 
    TODO: Move these to the types that need checks for recursive dependency (function declaration, struct declaration)
    For function declaration, it should be marked as resolved when the signature has been resolved
    instead of the whole function declaration including the body
    because the body can have function call that calls functions that are resolving
    or even recursive function call, which should be allowed.

    if(self->resolve_status == AST_RESOLVED) {
        return;
    } else if(self->resolve_status == AST_RESOLVING) {
        tokenizer_get_code_reference_index(&context->parser->tokenizer, ast_get_code_reference(self).data);
        tokenizer_print_error(&context->parser->tokenizer,
                              tokenizer_get_code_reference_index(&context->parser->tokenizer, ast_get_code_reference(self).data),
                              "Found recursive dependency");
        throw(AST_ERR);
    }
    */

    self->resolve_status = AST_RESOLVING;
    switch(self->type) {
        case AST_NONE:
        case AST_NUMBER:
            /* Nothing to resolve for numbers */
            break;
        case AST_FUNCTION_DECL:
            funcdecl_resolve(self->value.func_decl, context);
            break;
        case AST_FUNCTION_CALL:
            funccall_resolve(self->value.func_call, context);
            break;
        case AST_LHS:
            lhs_resolve(self->value.lhs_expr, context);
            break;
        case AST_IMPORT:
            /* TODO: When @import(...).data syntax is added, implement the resolve for it */
            break;
        case AST_STRING:
            /* TODO: Convert special combinations. For example \n to newline */
            break;
        case AST_VARIABLE:
            variable_resolve(self->value.variable, context);
            break;
        case AST_BINOP:
            binop_resolve(self->value.binop, context);
            break;
    }
    /*self->resolve_status = AST_RESOLVED;*/
}