#include <assert.h>

#include "express/expr.h"

/* core */
#include "express/hash.h"
#include "express/linklist.h"

/* non-core */
#include "express/dict.h"
#include "express/variable.h"

#include "driver.h"
#include "fff.h"

/*
 * mock globals
 */

char * EXPRESSprogram_name;
int yylineno;
int __SCOPE_search_id;

Error ERROR_warn_unsupported_lang_feat;
Error WARNING_case_skip_label;
Error ERROR_undefined_attribute;

/*
 * mock functions
 */

DEFINE_FFF_GLOBALS

FAKE_VALUE_FUNC(int, EXPRESS_fail, Express)
FAKE_VALUE_FUNC(Variable, ENTITYfind_inherited_attribute, struct Scope_ *, char *, struct Symbol_ **)
FAKE_VALUE_FUNC(Variable, ENTITYresolve_attr_ref, Entity, Symbol *, Symbol *)
FAKE_VALUE_FUNC(struct Scope_ *, ENTITYfind_inherited_entity, struct Scope_ *, char *, int)
FAKE_VOID_FUNC(EXP_resolve, Expression, Scope, Type)

void setup() {
    EXPinitialize();
    
    RESET_FAKE(EXPRESS_fail);
    RESET_FAKE(ENTITYfind_inherited_attribute);
    RESET_FAKE(ENTITYresolve_attr_ref);
    RESET_FAKE(ENTITYfind_inherited_entity);
    RESET_FAKE(EXP_resolve);
}

/* TODO: remove DICTlookup after eliminating DICT_type */
void EXP_resolve_type_handler(Expression exp, Scope cxt, Type typ) {
    (void) typ;
    Type res_typ = DICTlookup(cxt->symbol_table, exp->symbol.name); 
    exp->type = res_typ;
    exp->return_type = res_typ;
    exp->symbol.resolved = RESOLVED;
}

int test_resolve_select_enum_member() {
    Schema scope;
    Symbol *e_type_id, *enum_id, *s_type_id;
    Type enum_typ, select_typ, chk_typ;
    TypeBody tb;
    Expression expr, op1, op2, exp_enum_id;

    /*
     * boilerplate: create objects, populate symbol tables
     */
    scope = SCHEMAcreate();

    s_type_id = SYMBOLcreate("sel1", 1, "test1");
    e_type_id = SYMBOLcreate("enum1", 1, "test1");
    enum_id = SYMBOLcreate("val1", 1, "test1");
    
    enum_typ = TYPEcreate_name(e_type_id);
    enum_typ->symbol_table = DICTcreate(50);
    
    exp_enum_id = EXPcreate(enum_typ);
    exp_enum_id->symbol = *enum_id;
    exp_enum_id->u.integer = 1;
    
    tb = TYPEBODYcreate(enumeration_);
    tb->list = LISTcreate();
    LISTadd_last(tb->list, enum_id);
    enum_typ->u.type->body = tb;
    
    DICT_define(scope->symbol_table, e_type_id->name, enum_typ, &enum_typ->symbol, OBJ_TYPE);
    
    /* TODO: OBJ_ENUM / OBJ_EXPRESSION are used interchangeably, this is confusing. */
    DICT_define(scope->enum_table, exp_enum_id->symbol.name, exp_enum_id, &exp_enum_id->symbol, OBJ_EXPRESSION);
    DICT_define(enum_typ->symbol_table, enum_id->name, exp_enum_id, enum_id, OBJ_EXPRESSION);
    
    select_typ = TYPEcreate_name(s_type_id);
    tb = TYPEBODYcreate(select_);
    tb->list = LISTcreate();
    LISTadd_last(tb->list, enum_typ);
    select_typ->u.type->body = tb;
    DICT_define(scope->symbol_table, s_type_id->name, select_typ, &select_typ->symbol, OBJ_TYPE);
    
    op1 = EXPcreate_from_symbol(Type_Identifier, s_type_id);
    op2 = EXPcreate_from_symbol(Type_Identifier, enum_id);
    expr = BIN_EXPcreate(OP_DOT, op1, op2);    

    /*
     * test: sel_ref '.' enum_id
     * expectation: enum_typ
     */
    EXP_resolve_fake.custom_fake = EXP_resolve_type_handler;
    
    chk_typ = EXPresolve_op_dot(expr, scope);

    assert(EXP_resolve_fake.call_count == 1);
    assert(expr->e.op1->type == select_typ);
    assert(chk_typ == enum_typ);
    
    /* in case of error SIGABRT will be raised (and non-zero returned) */
    
    return 0;
}

/* TODO: remove DICTlookup after eliminating DICT_type */
void EXP_resolve_entity_handler(Expression exp, Scope cxt, Type unused) {
    (void) unused;
    Entity ent = DICTlookup(cxt->symbol_table, exp->symbol.name);
    Type typ = ent->u.entity->type;
    exp->type = typ;
    exp->return_type = typ;
    exp->symbol.resolved = RESOLVED;
}

Variable ENTITY_resolve_attr_handler(Entity ent, Symbol *grp_ref, Symbol *attr_ref) {
    (void) grp_ref;
    Variable v = DICTlookup(ent->symbol_table, attr_ref->name);
    return v;   
}

int test_resolve_entity_attribute() {
    Schema scope;
    Symbol *e_type_id, *attr_id;
    Entity ent;
    Type attr_typ, chk_typ;
    TypeBody tb;
    Expression exp_attr, expr, op1, op2;
    Variable var_attr;
    Linked_List explicit_attr_list;

    /*
     * boilerplate: create objects, populate symbol tables
     */
    scope = SCHEMAcreate();

    e_type_id = SYMBOLcreate("entity1", 1, "test2");
    ent = ENTITYcreate(e_type_id);
    DICT_define(scope->symbol_table, e_type_id->name, ent, &ent->symbol, OBJ_ENTITY);

    attr_id = SYMBOLcreate("attr1", 1, "test2");
    exp_attr = EXPcreate_from_symbol(Type_Attribute, attr_id);    
    tb = TYPEBODYcreate(number_);
    attr_typ = TYPEcreate_from_body_anonymously(tb);
    attr_typ->superscope = ent;
    var_attr = VARcreate(exp_attr, attr_typ);
    var_attr->flags.attribute = 1;
    explicit_attr_list = LISTcreate();
    LISTadd_last(explicit_attr_list, var_attr);
    
    LISTadd_last(ent->u.entity->attributes, explicit_attr_list);
    DICTdefine(ent->symbol_table, attr_id->name, var_attr, &var_attr->name->symbol, OBJ_VARIABLE);

    op1 = EXPcreate_from_symbol(Type_Identifier, e_type_id);
    op2 = EXPcreate_from_symbol(Type_Attribute, attr_id);
    expr = BIN_EXPcreate(OP_DOT, op1, op2);
    
    /*
     * test: entity_ref '.' attribute_id
     * expectation: attr_typ
     */
    EXP_resolve_fake.custom_fake = EXP_resolve_entity_handler;
    ENTITYresolve_attr_ref_fake.custom_fake = ENTITY_resolve_attr_handler;
    
    chk_typ = EXPresolve_op_dot(expr, scope);

    assert(EXP_resolve_fake.call_count == 1);
    assert(expr->e.op1->type == ent->u.entity->type);
    assert(chk_typ == attr_typ);
    
    /* in case of error SIGABRT will be raised (and non-zero returned) */
    
    return 0;
}

struct test_def tests[] = {
    {"resolve_select_enum_member", test_resolve_select_enum_member},
    {"resolve_entity_attribute", test_resolve_entity_attribute},
    {NULL}
};